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_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
3871         }
3872         if (ndr_flags & NDR_BUFFERS) {
3873         }
3874         return NDR_ERR_SUCCESS;
3875 }
3876
3877 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
3878 {
3879         if (ndr_flags & NDR_SCALARS) {
3880                 NDR_CHECK(ndr_pull_align(ndr, 4));
3881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
3882         }
3883         if (ndr_flags & NDR_BUFFERS) {
3884         }
3885         return NDR_ERR_SUCCESS;
3886 }
3887
3888 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
3889 {
3890         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
3891         ndr->depth++;
3892         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
3893         ndr->depth--;
3894 }
3895
3896 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
3897 {
3898         if (ndr_flags & NDR_SCALARS) {
3899                 NDR_CHECK(ndr_push_align(ndr, 4));
3900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3901                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3902                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3903         }
3904         if (ndr_flags & NDR_BUFFERS) {
3905                 if (r->printername) {
3906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3910                 }
3911                 if (r->servername) {
3912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3913                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3914                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3915                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3916                 }
3917         }
3918         return NDR_ERR_SUCCESS;
3919 }
3920
3921 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
3922 {
3923         uint32_t _ptr_printername;
3924         TALLOC_CTX *_mem_save_printername_0;
3925         uint32_t _ptr_servername;
3926         TALLOC_CTX *_mem_save_servername_0;
3927         if (ndr_flags & NDR_SCALARS) {
3928                 NDR_CHECK(ndr_pull_align(ndr, 4));
3929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3930                 if (_ptr_printername) {
3931                         NDR_PULL_ALLOC(ndr, r->printername);
3932                 } else {
3933                         r->printername = NULL;
3934                 }
3935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3936                 if (_ptr_servername) {
3937                         NDR_PULL_ALLOC(ndr, r->servername);
3938                 } else {
3939                         r->servername = NULL;
3940                 }
3941                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3942         }
3943         if (ndr_flags & NDR_BUFFERS) {
3944                 if (r->printername) {
3945                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3946                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3947                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3948                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3949                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3950                                 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));
3951                         }
3952                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3953                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3955                 }
3956                 if (r->servername) {
3957                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3958                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3961                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3962                                 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));
3963                         }
3964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3967                 }
3968         }
3969         return NDR_ERR_SUCCESS;
3970 }
3971
3972 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
3973 {
3974         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
3975         ndr->depth++;
3976         ndr_print_ptr(ndr, "printername", r->printername);
3977         ndr->depth++;
3978         if (r->printername) {
3979                 ndr_print_string(ndr, "printername", r->printername);
3980         }
3981         ndr->depth--;
3982         ndr_print_ptr(ndr, "servername", r->servername);
3983         ndr->depth++;
3984         if (r->servername) {
3985                 ndr_print_string(ndr, "servername", r->servername);
3986         }
3987         ndr->depth--;
3988         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
3989         ndr->depth--;
3990 }
3991
3992 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
3993 {
3994         if (ndr_flags & NDR_SCALARS) {
3995                 NDR_CHECK(ndr_push_align(ndr, 4));
3996                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
3998                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
4000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
4001         }
4002         if (ndr_flags & NDR_BUFFERS) {
4003                 if (r->printername) {
4004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4006                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4007                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4008                 }
4009                 if (r->portname) {
4010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4013                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4014                 }
4015         }
4016         return NDR_ERR_SUCCESS;
4017 }
4018
4019 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
4020 {
4021         uint32_t _ptr_printername;
4022         TALLOC_CTX *_mem_save_printername_0;
4023         uint32_t _ptr_portname;
4024         TALLOC_CTX *_mem_save_portname_0;
4025         if (ndr_flags & NDR_SCALARS) {
4026                 NDR_CHECK(ndr_pull_align(ndr, 4));
4027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4028                 if (_ptr_printername) {
4029                         NDR_PULL_ALLOC(ndr, r->printername);
4030                 } else {
4031                         r->printername = NULL;
4032                 }
4033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
4034                 if (_ptr_portname) {
4035                         NDR_PULL_ALLOC(ndr, r->portname);
4036                 } else {
4037                         r->portname = NULL;
4038                 }
4039                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
4040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
4041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
4042         }
4043         if (ndr_flags & NDR_BUFFERS) {
4044                 if (r->printername) {
4045                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4046                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4048                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4049                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4050                                 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));
4051                         }
4052                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4053                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4055                 }
4056                 if (r->portname) {
4057                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
4058                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
4059                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
4060                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
4061                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
4062                                 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));
4063                         }
4064                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
4065                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
4066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
4067                 }
4068         }
4069         return NDR_ERR_SUCCESS;
4070 }
4071
4072 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
4073 {
4074         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
4075         ndr->depth++;
4076         ndr_print_ptr(ndr, "printername", r->printername);
4077         ndr->depth++;
4078         if (r->printername) {
4079                 ndr_print_string(ndr, "printername", r->printername);
4080         }
4081         ndr->depth--;
4082         ndr_print_ptr(ndr, "portname", r->portname);
4083         ndr->depth++;
4084         if (r->portname) {
4085                 ndr_print_string(ndr, "portname", r->portname);
4086         }
4087         ndr->depth--;
4088         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4089         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
4090         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
4091         ndr->depth--;
4092 }
4093
4094 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
4095 {
4096         if (ndr_flags & NDR_SCALARS) {
4097                 NDR_CHECK(ndr_push_align(ndr, 4));
4098                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
4099         }
4100         if (ndr_flags & NDR_BUFFERS) {
4101         }
4102         return NDR_ERR_SUCCESS;
4103 }
4104
4105 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
4106 {
4107         if (ndr_flags & NDR_SCALARS) {
4108                 NDR_CHECK(ndr_pull_align(ndr, 4));
4109                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
4110         }
4111         if (ndr_flags & NDR_BUFFERS) {
4112         }
4113         return NDR_ERR_SUCCESS;
4114 }
4115
4116 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
4117 {
4118         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
4119         ndr->depth++;
4120         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
4121         ndr->depth--;
4122 }
4123
4124 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
4125 {
4126         if (ndr_flags & NDR_SCALARS) {
4127                 NDR_CHECK(ndr_push_align(ndr, 4));
4128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
4129                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
4130         }
4131         if (ndr_flags & NDR_BUFFERS) {
4132                 if (r->guid) {
4133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4136                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4137                 }
4138         }
4139         return NDR_ERR_SUCCESS;
4140 }
4141
4142 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
4143 {
4144         uint32_t _ptr_guid;
4145         TALLOC_CTX *_mem_save_guid_0;
4146         if (ndr_flags & NDR_SCALARS) {
4147                 NDR_CHECK(ndr_pull_align(ndr, 4));
4148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
4149                 if (_ptr_guid) {
4150                         NDR_PULL_ALLOC(ndr, r->guid);
4151                 } else {
4152                         r->guid = NULL;
4153                 }
4154                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
4155         }
4156         if (ndr_flags & NDR_BUFFERS) {
4157                 if (r->guid) {
4158                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4159                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
4160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
4161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
4162                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
4163                                 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));
4164                         }
4165                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
4166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
4167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
4168                 }
4169         }
4170         return NDR_ERR_SUCCESS;
4171 }
4172
4173 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
4174 {
4175         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
4176         ndr->depth++;
4177         ndr_print_ptr(ndr, "guid", r->guid);
4178         ndr->depth++;
4179         if (r->guid) {
4180                 ndr_print_string(ndr, "guid", r->guid);
4181         }
4182         ndr->depth--;
4183         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
4184         ndr->depth--;
4185 }
4186
4187 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
4188 {
4189         if (ndr_flags & NDR_SCALARS) {
4190                 int level = ndr_push_get_switch_value(ndr, r);
4191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4192                 switch (level) {
4193                         case 0: {
4194                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4195                         break; }
4196
4197                         case 1: {
4198                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4199                         break; }
4200
4201                         case 2: {
4202                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4203                         break; }
4204
4205                         case 3: {
4206                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4207                         break; }
4208
4209                         case 4: {
4210                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
4211                         break; }
4212
4213                         case 5: {
4214                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
4215                         break; }
4216
4217                         case 6: {
4218                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
4219                         break; }
4220
4221                         case 7: {
4222                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
4223                         break; }
4224
4225                         case 8: {
4226                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
4227                         break; }
4228
4229                         case 9: {
4230                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
4231                         break; }
4232
4233                         default: {
4234                         break; }
4235
4236                 }
4237         }
4238         if (ndr_flags & NDR_BUFFERS) {
4239                 int level = ndr_push_get_switch_value(ndr, r);
4240                 switch (level) {
4241                         case 0:
4242                                 if (r->info0) {
4243                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4244                                 }
4245                         break;
4246
4247                         case 1:
4248                                 if (r->info1) {
4249                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4250                                 }
4251                         break;
4252
4253                         case 2:
4254                                 if (r->info2) {
4255                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4256                                 }
4257                         break;
4258
4259                         case 3:
4260                                 if (r->info3) {
4261                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
4262                                 }
4263                         break;
4264
4265                         case 4:
4266                                 if (r->info4) {
4267                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4268                                 }
4269                         break;
4270
4271                         case 5:
4272                                 if (r->info5) {
4273                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4274                                 }
4275                         break;
4276
4277                         case 6:
4278                                 if (r->info6) {
4279                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4280                                 }
4281                         break;
4282
4283                         case 7:
4284                                 if (r->info7) {
4285                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4286                                 }
4287                         break;
4288
4289                         case 8:
4290                                 if (r->info8) {
4291                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4292                                 }
4293                         break;
4294
4295                         case 9:
4296                                 if (r->info9) {
4297                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4298                                 }
4299                         break;
4300
4301                         default:
4302                         break;
4303
4304                 }
4305         }
4306         return NDR_ERR_SUCCESS;
4307 }
4308
4309 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
4310 {
4311         int level;
4312         uint32_t _level;
4313         TALLOC_CTX *_mem_save_info0_0;
4314         TALLOC_CTX *_mem_save_info1_0;
4315         TALLOC_CTX *_mem_save_info2_0;
4316         TALLOC_CTX *_mem_save_info3_0;
4317         TALLOC_CTX *_mem_save_info4_0;
4318         TALLOC_CTX *_mem_save_info5_0;
4319         TALLOC_CTX *_mem_save_info6_0;
4320         TALLOC_CTX *_mem_save_info7_0;
4321         TALLOC_CTX *_mem_save_info8_0;
4322         TALLOC_CTX *_mem_save_info9_0;
4323         level = ndr_pull_get_switch_value(ndr, r);
4324         if (ndr_flags & NDR_SCALARS) {
4325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4326                 if (_level != level) {
4327                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4328                 }
4329                 switch (level) {
4330                         case 0: {
4331                                 uint32_t _ptr_info0;
4332                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4333                                 if (_ptr_info0) {
4334                                         NDR_PULL_ALLOC(ndr, r->info0);
4335                                 } else {
4336                                         r->info0 = NULL;
4337                                 }
4338                         break; }
4339
4340                         case 1: {
4341                                 uint32_t _ptr_info1;
4342                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4343                                 if (_ptr_info1) {
4344                                         NDR_PULL_ALLOC(ndr, r->info1);
4345                                 } else {
4346                                         r->info1 = NULL;
4347                                 }
4348                         break; }
4349
4350                         case 2: {
4351                                 uint32_t _ptr_info2;
4352                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4353                                 if (_ptr_info2) {
4354                                         NDR_PULL_ALLOC(ndr, r->info2);
4355                                 } else {
4356                                         r->info2 = NULL;
4357                                 }
4358                         break; }
4359
4360                         case 3: {
4361                                 uint32_t _ptr_info3;
4362                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4363                                 if (_ptr_info3) {
4364                                         NDR_PULL_ALLOC(ndr, r->info3);
4365                                 } else {
4366                                         r->info3 = NULL;
4367                                 }
4368                         break; }
4369
4370                         case 4: {
4371                                 uint32_t _ptr_info4;
4372                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
4373                                 if (_ptr_info4) {
4374                                         NDR_PULL_ALLOC(ndr, r->info4);
4375                                 } else {
4376                                         r->info4 = NULL;
4377                                 }
4378                         break; }
4379
4380                         case 5: {
4381                                 uint32_t _ptr_info5;
4382                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
4383                                 if (_ptr_info5) {
4384                                         NDR_PULL_ALLOC(ndr, r->info5);
4385                                 } else {
4386                                         r->info5 = NULL;
4387                                 }
4388                         break; }
4389
4390                         case 6: {
4391                                 uint32_t _ptr_info6;
4392                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
4393                                 if (_ptr_info6) {
4394                                         NDR_PULL_ALLOC(ndr, r->info6);
4395                                 } else {
4396                                         r->info6 = NULL;
4397                                 }
4398                         break; }
4399
4400                         case 7: {
4401                                 uint32_t _ptr_info7;
4402                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
4403                                 if (_ptr_info7) {
4404                                         NDR_PULL_ALLOC(ndr, r->info7);
4405                                 } else {
4406                                         r->info7 = NULL;
4407                                 }
4408                         break; }
4409
4410                         case 8: {
4411                                 uint32_t _ptr_info8;
4412                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
4413                                 if (_ptr_info8) {
4414                                         NDR_PULL_ALLOC(ndr, r->info8);
4415                                 } else {
4416                                         r->info8 = NULL;
4417                                 }
4418                         break; }
4419
4420                         case 9: {
4421                                 uint32_t _ptr_info9;
4422                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
4423                                 if (_ptr_info9) {
4424                                         NDR_PULL_ALLOC(ndr, r->info9);
4425                                 } else {
4426                                         r->info9 = NULL;
4427                                 }
4428                         break; }
4429
4430                         default: {
4431                         break; }
4432
4433                 }
4434         }
4435         if (ndr_flags & NDR_BUFFERS) {
4436                 switch (level) {
4437                         case 0:
4438                                 if (r->info0) {
4439                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4440                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4441                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4442                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4443                                 }
4444                         break;
4445
4446                         case 1:
4447                                 if (r->info1) {
4448                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4449                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4450                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4451                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4452                                 }
4453                         break;
4454
4455                         case 2:
4456                                 if (r->info2) {
4457                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4458                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4459                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4460                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4461                                 }
4462                         break;
4463
4464                         case 3:
4465                                 if (r->info3) {
4466                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4467                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4468                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
4469                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4470                                 }
4471                         break;
4472
4473                         case 4:
4474                                 if (r->info4) {
4475                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
4476                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
4477                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4478                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
4479                                 }
4480                         break;
4481
4482                         case 5:
4483                                 if (r->info5) {
4484                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
4485                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
4486                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4487                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
4488                                 }
4489                         break;
4490
4491                         case 6:
4492                                 if (r->info6) {
4493                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
4494                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
4495                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4496                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
4497                                 }
4498                         break;
4499
4500                         case 7:
4501                                 if (r->info7) {
4502                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
4503                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
4504                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4505                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
4506                                 }
4507                         break;
4508
4509                         case 8:
4510                                 if (r->info8) {
4511                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
4512                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
4513                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4514                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
4515                                 }
4516                         break;
4517
4518                         case 9:
4519                                 if (r->info9) {
4520                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
4521                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
4522                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4523                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
4524                                 }
4525                         break;
4526
4527                         default:
4528                         break;
4529
4530                 }
4531         }
4532         return NDR_ERR_SUCCESS;
4533 }
4534
4535 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
4536 {
4537         int level;
4538         level = ndr_print_get_switch_value(ndr, r);
4539         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
4540         switch (level) {
4541                 case 0:
4542                         ndr_print_ptr(ndr, "info0", r->info0);
4543                         ndr->depth++;
4544                         if (r->info0) {
4545                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
4546                         }
4547                         ndr->depth--;
4548                 break;
4549
4550                 case 1:
4551                         ndr_print_ptr(ndr, "info1", r->info1);
4552                         ndr->depth++;
4553                         if (r->info1) {
4554                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
4555                         }
4556                         ndr->depth--;
4557                 break;
4558
4559                 case 2:
4560                         ndr_print_ptr(ndr, "info2", r->info2);
4561                         ndr->depth++;
4562                         if (r->info2) {
4563                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
4564                         }
4565                         ndr->depth--;
4566                 break;
4567
4568                 case 3:
4569                         ndr_print_ptr(ndr, "info3", r->info3);
4570                         ndr->depth++;
4571                         if (r->info3) {
4572                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
4573                         }
4574                         ndr->depth--;
4575                 break;
4576
4577                 case 4:
4578                         ndr_print_ptr(ndr, "info4", r->info4);
4579                         ndr->depth++;
4580                         if (r->info4) {
4581                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
4582                         }
4583                         ndr->depth--;
4584                 break;
4585
4586                 case 5:
4587                         ndr_print_ptr(ndr, "info5", r->info5);
4588                         ndr->depth++;
4589                         if (r->info5) {
4590                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
4591                         }
4592                         ndr->depth--;
4593                 break;
4594
4595                 case 6:
4596                         ndr_print_ptr(ndr, "info6", r->info6);
4597                         ndr->depth++;
4598                         if (r->info6) {
4599                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
4600                         }
4601                         ndr->depth--;
4602                 break;
4603
4604                 case 7:
4605                         ndr_print_ptr(ndr, "info7", r->info7);
4606                         ndr->depth++;
4607                         if (r->info7) {
4608                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
4609                         }
4610                         ndr->depth--;
4611                 break;
4612
4613                 case 8:
4614                         ndr_print_ptr(ndr, "info8", r->info8);
4615                         ndr->depth++;
4616                         if (r->info8) {
4617                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
4618                         }
4619                         ndr->depth--;
4620                 break;
4621
4622                 case 9:
4623                         ndr_print_ptr(ndr, "info9", r->info9);
4624                         ndr->depth++;
4625                         if (r->info9) {
4626                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
4627                         }
4628                         ndr->depth--;
4629                 break;
4630
4631                 default:
4632                 break;
4633
4634         }
4635 }
4636
4637 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
4638 {
4639         if (ndr_flags & NDR_SCALARS) {
4640                 NDR_CHECK(ndr_push_align(ndr, 4));
4641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4642                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
4643                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4644         }
4645         if (ndr_flags & NDR_BUFFERS) {
4646                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4647         }
4648         return NDR_ERR_SUCCESS;
4649 }
4650
4651 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
4652 {
4653         if (ndr_flags & NDR_SCALARS) {
4654                 NDR_CHECK(ndr_pull_align(ndr, 4));
4655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4656                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
4657                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4658         }
4659         if (ndr_flags & NDR_BUFFERS) {
4660                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4661         }
4662         return NDR_ERR_SUCCESS;
4663 }
4664
4665 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
4666 {
4667         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
4668         ndr->depth++;
4669         ndr_print_uint32(ndr, "level", r->level);
4670         ndr_print_set_switch_value(ndr, &r->info, r->level);
4671         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
4672         ndr->depth--;
4673 }
4674
4675 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
4676 {
4677         if (ndr_flags & NDR_SCALARS) {
4678                 NDR_CHECK(ndr_push_align(ndr, 4));
4679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
4680                 {
4681                         uint32_t _flags_save_string_array = ndr->flags;
4682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4683                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
4684                         ndr->flags = _flags_save_string_array;
4685                 }
4686         }
4687         if (ndr_flags & NDR_BUFFERS) {
4688         }
4689         return NDR_ERR_SUCCESS;
4690 }
4691
4692 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
4693 {
4694         if (ndr_flags & NDR_SCALARS) {
4695                 NDR_CHECK(ndr_pull_align(ndr, 4));
4696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
4697                 {
4698                         uint32_t _flags_save_string_array = ndr->flags;
4699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4700                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
4701                         ndr->flags = _flags_save_string_array;
4702                 }
4703         }
4704         if (ndr_flags & NDR_BUFFERS) {
4705         }
4706         return NDR_ERR_SUCCESS;
4707 }
4708
4709 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
4710 {
4711         ndr_print_struct(ndr, name, "spoolss_StringArray");
4712         ndr->depth++;
4713         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);
4714         ndr_print_string_array(ndr, "string", r->string);
4715         ndr->depth--;
4716 }
4717
4718 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
4719 {
4720         if (ndr_flags & NDR_SCALARS) {
4721                 NDR_CHECK(ndr_push_align(ndr, 4));
4722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4723         }
4724         if (ndr_flags & NDR_BUFFERS) {
4725                 if (r->driver_name) {
4726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4730                 }
4731         }
4732         return NDR_ERR_SUCCESS;
4733 }
4734
4735 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
4736 {
4737         uint32_t _ptr_driver_name;
4738         TALLOC_CTX *_mem_save_driver_name_0;
4739         if (ndr_flags & NDR_SCALARS) {
4740                 NDR_CHECK(ndr_pull_align(ndr, 4));
4741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4742                 if (_ptr_driver_name) {
4743                         NDR_PULL_ALLOC(ndr, r->driver_name);
4744                 } else {
4745                         r->driver_name = NULL;
4746                 }
4747         }
4748         if (ndr_flags & NDR_BUFFERS) {
4749                 if (r->driver_name) {
4750                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4751                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4754                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4755                                 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));
4756                         }
4757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4758                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4760                 }
4761         }
4762         return NDR_ERR_SUCCESS;
4763 }
4764
4765 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
4766 {
4767         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
4768         ndr->depth++;
4769         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4770         ndr->depth++;
4771         if (r->driver_name) {
4772                 ndr_print_string(ndr, "driver_name", r->driver_name);
4773         }
4774         ndr->depth--;
4775         ndr->depth--;
4776 }
4777
4778 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
4779 {
4780         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4781         return NDR_ERR_SUCCESS;
4782 }
4783
4784 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
4785 {
4786         uint32_t v;
4787         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4788         *r = v;
4789         return NDR_ERR_SUCCESS;
4790 }
4791
4792 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
4793 {
4794         const char *val = NULL;
4795
4796         switch (r) {
4797                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
4798                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
4799                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
4800                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
4801         }
4802         ndr_print_enum(ndr, name, "ENUM", val, r);
4803 }
4804
4805 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
4806 {
4807         if (ndr_flags & NDR_SCALARS) {
4808                 NDR_CHECK(ndr_push_align(ndr, 4));
4809                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
4812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
4813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
4814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
4815         }
4816         if (ndr_flags & NDR_BUFFERS) {
4817                 if (r->driver_name) {
4818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4822                 }
4823                 if (r->architecture) {
4824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4825                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4828                 }
4829                 if (r->driver_path) {
4830                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4831                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4832                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4833                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4834                 }
4835                 if (r->data_file) {
4836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4838                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4839                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4840                 }
4841                 if (r->config_file) {
4842                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4843                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4845                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4846                 }
4847         }
4848         return NDR_ERR_SUCCESS;
4849 }
4850
4851 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
4852 {
4853         uint32_t _ptr_driver_name;
4854         TALLOC_CTX *_mem_save_driver_name_0;
4855         uint32_t _ptr_architecture;
4856         TALLOC_CTX *_mem_save_architecture_0;
4857         uint32_t _ptr_driver_path;
4858         TALLOC_CTX *_mem_save_driver_path_0;
4859         uint32_t _ptr_data_file;
4860         TALLOC_CTX *_mem_save_data_file_0;
4861         uint32_t _ptr_config_file;
4862         TALLOC_CTX *_mem_save_config_file_0;
4863         if (ndr_flags & NDR_SCALARS) {
4864                 NDR_CHECK(ndr_pull_align(ndr, 4));
4865                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4867                 if (_ptr_driver_name) {
4868                         NDR_PULL_ALLOC(ndr, r->driver_name);
4869                 } else {
4870                         r->driver_name = NULL;
4871                 }
4872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4873                 if (_ptr_architecture) {
4874                         NDR_PULL_ALLOC(ndr, r->architecture);
4875                 } else {
4876                         r->architecture = NULL;
4877                 }
4878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4879                 if (_ptr_driver_path) {
4880                         NDR_PULL_ALLOC(ndr, r->driver_path);
4881                 } else {
4882                         r->driver_path = NULL;
4883                 }
4884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4885                 if (_ptr_data_file) {
4886                         NDR_PULL_ALLOC(ndr, r->data_file);
4887                 } else {
4888                         r->data_file = NULL;
4889                 }
4890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4891                 if (_ptr_config_file) {
4892                         NDR_PULL_ALLOC(ndr, r->config_file);
4893                 } else {
4894                         r->config_file = NULL;
4895                 }
4896         }
4897         if (ndr_flags & NDR_BUFFERS) {
4898                 if (r->driver_name) {
4899                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4900                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4901                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4902                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4903                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4904                                 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));
4905                         }
4906                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4907                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4909                 }
4910                 if (r->architecture) {
4911                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4912                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
4914                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
4915                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
4916                                 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));
4917                         }
4918                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
4919                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
4920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4921                 }
4922                 if (r->driver_path) {
4923                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4924                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4925                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
4926                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
4927                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
4928                                 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));
4929                         }
4930                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
4931                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
4932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4933                 }
4934                 if (r->data_file) {
4935                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4936                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4937                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
4938                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
4939                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
4940                                 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));
4941                         }
4942                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
4943                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
4944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4945                 }
4946                 if (r->config_file) {
4947                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4948                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4949                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
4950                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
4951                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
4952                                 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));
4953                         }
4954                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
4955                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
4956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4957                 }
4958         }
4959         return NDR_ERR_SUCCESS;
4960 }
4961
4962 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
4963 {
4964         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
4965         ndr->depth++;
4966         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4967         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4968         ndr->depth++;
4969         if (r->driver_name) {
4970                 ndr_print_string(ndr, "driver_name", r->driver_name);
4971         }
4972         ndr->depth--;
4973         ndr_print_ptr(ndr, "architecture", r->architecture);
4974         ndr->depth++;
4975         if (r->architecture) {
4976                 ndr_print_string(ndr, "architecture", r->architecture);
4977         }
4978         ndr->depth--;
4979         ndr_print_ptr(ndr, "driver_path", r->driver_path);
4980         ndr->depth++;
4981         if (r->driver_path) {
4982                 ndr_print_string(ndr, "driver_path", r->driver_path);
4983         }
4984         ndr->depth--;
4985         ndr_print_ptr(ndr, "data_file", r->data_file);
4986         ndr->depth++;
4987         if (r->data_file) {
4988                 ndr_print_string(ndr, "data_file", r->data_file);
4989         }
4990         ndr->depth--;
4991         ndr_print_ptr(ndr, "config_file", r->config_file);
4992         ndr->depth++;
4993         if (r->config_file) {
4994                 ndr_print_string(ndr, "config_file", r->config_file);
4995         }
4996         ndr->depth--;
4997         ndr->depth--;
4998 }
4999
5000 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
5001 {
5002         if (ndr_flags & NDR_SCALARS) {
5003                 NDR_CHECK(ndr_push_align(ndr, 4));
5004                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5006                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5009                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5015         }
5016         if (ndr_flags & NDR_BUFFERS) {
5017                 if (r->driver_name) {
5018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5021                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5022                 }
5023                 if (r->architecture) {
5024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5027                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5028                 }
5029                 if (r->driver_path) {
5030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5033                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5034                 }
5035                 if (r->data_file) {
5036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5039                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5040                 }
5041                 if (r->config_file) {
5042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5045                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5046                 }
5047                 if (r->help_file) {
5048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5051                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5052                 }
5053                 if (r->monitor_name) {
5054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5057                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5058                 }
5059                 if (r->default_datatype) {
5060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5063                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5064                 }
5065                 if (r->dependent_files) {
5066                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5067                 }
5068         }
5069         return NDR_ERR_SUCCESS;
5070 }
5071
5072 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
5073 {
5074         uint32_t _ptr_driver_name;
5075         TALLOC_CTX *_mem_save_driver_name_0;
5076         uint32_t _ptr_architecture;
5077         TALLOC_CTX *_mem_save_architecture_0;
5078         uint32_t _ptr_driver_path;
5079         TALLOC_CTX *_mem_save_driver_path_0;
5080         uint32_t _ptr_data_file;
5081         TALLOC_CTX *_mem_save_data_file_0;
5082         uint32_t _ptr_config_file;
5083         TALLOC_CTX *_mem_save_config_file_0;
5084         uint32_t _ptr_help_file;
5085         TALLOC_CTX *_mem_save_help_file_0;
5086         uint32_t _ptr_monitor_name;
5087         TALLOC_CTX *_mem_save_monitor_name_0;
5088         uint32_t _ptr_default_datatype;
5089         TALLOC_CTX *_mem_save_default_datatype_0;
5090         uint32_t _ptr_dependent_files;
5091         TALLOC_CTX *_mem_save_dependent_files_0;
5092         if (ndr_flags & NDR_SCALARS) {
5093                 NDR_CHECK(ndr_pull_align(ndr, 4));
5094                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5096                 if (_ptr_driver_name) {
5097                         NDR_PULL_ALLOC(ndr, r->driver_name);
5098                 } else {
5099                         r->driver_name = NULL;
5100                 }
5101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5102                 if (_ptr_architecture) {
5103                         NDR_PULL_ALLOC(ndr, r->architecture);
5104                 } else {
5105                         r->architecture = NULL;
5106                 }
5107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5108                 if (_ptr_driver_path) {
5109                         NDR_PULL_ALLOC(ndr, r->driver_path);
5110                 } else {
5111                         r->driver_path = NULL;
5112                 }
5113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5114                 if (_ptr_data_file) {
5115                         NDR_PULL_ALLOC(ndr, r->data_file);
5116                 } else {
5117                         r->data_file = NULL;
5118                 }
5119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5120                 if (_ptr_config_file) {
5121                         NDR_PULL_ALLOC(ndr, r->config_file);
5122                 } else {
5123                         r->config_file = NULL;
5124                 }
5125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5126                 if (_ptr_help_file) {
5127                         NDR_PULL_ALLOC(ndr, r->help_file);
5128                 } else {
5129                         r->help_file = NULL;
5130                 }
5131                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5132                 if (_ptr_monitor_name) {
5133                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5134                 } else {
5135                         r->monitor_name = NULL;
5136                 }
5137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5138                 if (_ptr_default_datatype) {
5139                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5140                 } else {
5141                         r->default_datatype = NULL;
5142                 }
5143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5145                 if (_ptr_dependent_files) {
5146                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5147                 } else {
5148                         r->dependent_files = NULL;
5149                 }
5150         }
5151         if (ndr_flags & NDR_BUFFERS) {
5152                 if (r->driver_name) {
5153                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5154                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5156                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5157                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5158                                 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));
5159                         }
5160                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5161                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5163                 }
5164                 if (r->architecture) {
5165                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5166                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5167                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5168                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5169                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5170                                 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));
5171                         }
5172                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5173                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5174                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5175                 }
5176                 if (r->driver_path) {
5177                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5178                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5180                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5181                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5182                                 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));
5183                         }
5184                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5185                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5187                 }
5188                 if (r->data_file) {
5189                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5190                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5192                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5193                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5194                                 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));
5195                         }
5196                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5197                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5198                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5199                 }
5200                 if (r->config_file) {
5201                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5202                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5205                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5206                                 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));
5207                         }
5208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5211                 }
5212                 if (r->help_file) {
5213                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5214                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5215                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5216                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5217                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5218                                 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));
5219                         }
5220                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5221                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5222                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5223                 }
5224                 if (r->monitor_name) {
5225                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5226                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5228                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5229                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5230                                 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));
5231                         }
5232                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5233                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5235                 }
5236                 if (r->default_datatype) {
5237                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5238                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5241                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5242                                 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));
5243                         }
5244                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5245                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5247                 }
5248                 if (r->dependent_files) {
5249                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5250                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5251                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5253                 }
5254         }
5255         return NDR_ERR_SUCCESS;
5256 }
5257
5258 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
5259 {
5260         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
5261         ndr->depth++;
5262         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5263         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5264         ndr->depth++;
5265         if (r->driver_name) {
5266                 ndr_print_string(ndr, "driver_name", r->driver_name);
5267         }
5268         ndr->depth--;
5269         ndr_print_ptr(ndr, "architecture", r->architecture);
5270         ndr->depth++;
5271         if (r->architecture) {
5272                 ndr_print_string(ndr, "architecture", r->architecture);
5273         }
5274         ndr->depth--;
5275         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5276         ndr->depth++;
5277         if (r->driver_path) {
5278                 ndr_print_string(ndr, "driver_path", r->driver_path);
5279         }
5280         ndr->depth--;
5281         ndr_print_ptr(ndr, "data_file", r->data_file);
5282         ndr->depth++;
5283         if (r->data_file) {
5284                 ndr_print_string(ndr, "data_file", r->data_file);
5285         }
5286         ndr->depth--;
5287         ndr_print_ptr(ndr, "config_file", r->config_file);
5288         ndr->depth++;
5289         if (r->config_file) {
5290                 ndr_print_string(ndr, "config_file", r->config_file);
5291         }
5292         ndr->depth--;
5293         ndr_print_ptr(ndr, "help_file", r->help_file);
5294         ndr->depth++;
5295         if (r->help_file) {
5296                 ndr_print_string(ndr, "help_file", r->help_file);
5297         }
5298         ndr->depth--;
5299         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5300         ndr->depth++;
5301         if (r->monitor_name) {
5302                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5303         }
5304         ndr->depth--;
5305         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5306         ndr->depth++;
5307         if (r->default_datatype) {
5308                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5309         }
5310         ndr->depth--;
5311         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);
5312         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5313         ndr->depth++;
5314         if (r->dependent_files) {
5315                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5316         }
5317         ndr->depth--;
5318         ndr->depth--;
5319 }
5320
5321 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
5322 {
5323         if (ndr_flags & NDR_SCALARS) {
5324                 NDR_CHECK(ndr_push_align(ndr, 4));
5325                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5329                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5333                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5337                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5338         }
5339         if (ndr_flags & NDR_BUFFERS) {
5340                 if (r->driver_name) {
5341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5344                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5345                 }
5346                 if (r->architecture) {
5347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5350                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5351                 }
5352                 if (r->driver_path) {
5353                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5354                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5356                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5357                 }
5358                 if (r->data_file) {
5359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5363                 }
5364                 if (r->config_file) {
5365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5368                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5369                 }
5370                 if (r->help_file) {
5371                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5374                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5375                 }
5376                 if (r->monitor_name) {
5377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5380                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5381                 }
5382                 if (r->default_datatype) {
5383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5387                 }
5388                 if (r->dependent_files) {
5389                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5390                 }
5391                 if (r->previous_names) {
5392                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5393                 }
5394         }
5395         return NDR_ERR_SUCCESS;
5396 }
5397
5398 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
5399 {
5400         uint32_t _ptr_driver_name;
5401         TALLOC_CTX *_mem_save_driver_name_0;
5402         uint32_t _ptr_architecture;
5403         TALLOC_CTX *_mem_save_architecture_0;
5404         uint32_t _ptr_driver_path;
5405         TALLOC_CTX *_mem_save_driver_path_0;
5406         uint32_t _ptr_data_file;
5407         TALLOC_CTX *_mem_save_data_file_0;
5408         uint32_t _ptr_config_file;
5409         TALLOC_CTX *_mem_save_config_file_0;
5410         uint32_t _ptr_help_file;
5411         TALLOC_CTX *_mem_save_help_file_0;
5412         uint32_t _ptr_monitor_name;
5413         TALLOC_CTX *_mem_save_monitor_name_0;
5414         uint32_t _ptr_default_datatype;
5415         TALLOC_CTX *_mem_save_default_datatype_0;
5416         uint32_t _ptr_dependent_files;
5417         TALLOC_CTX *_mem_save_dependent_files_0;
5418         uint32_t _ptr_previous_names;
5419         TALLOC_CTX *_mem_save_previous_names_0;
5420         if (ndr_flags & NDR_SCALARS) {
5421                 NDR_CHECK(ndr_pull_align(ndr, 4));
5422                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5424                 if (_ptr_driver_name) {
5425                         NDR_PULL_ALLOC(ndr, r->driver_name);
5426                 } else {
5427                         r->driver_name = NULL;
5428                 }
5429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5430                 if (_ptr_architecture) {
5431                         NDR_PULL_ALLOC(ndr, r->architecture);
5432                 } else {
5433                         r->architecture = NULL;
5434                 }
5435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5436                 if (_ptr_driver_path) {
5437                         NDR_PULL_ALLOC(ndr, r->driver_path);
5438                 } else {
5439                         r->driver_path = NULL;
5440                 }
5441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5442                 if (_ptr_data_file) {
5443                         NDR_PULL_ALLOC(ndr, r->data_file);
5444                 } else {
5445                         r->data_file = NULL;
5446                 }
5447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5448                 if (_ptr_config_file) {
5449                         NDR_PULL_ALLOC(ndr, r->config_file);
5450                 } else {
5451                         r->config_file = NULL;
5452                 }
5453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5454                 if (_ptr_help_file) {
5455                         NDR_PULL_ALLOC(ndr, r->help_file);
5456                 } else {
5457                         r->help_file = NULL;
5458                 }
5459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5460                 if (_ptr_monitor_name) {
5461                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5462                 } else {
5463                         r->monitor_name = NULL;
5464                 }
5465                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5466                 if (_ptr_default_datatype) {
5467                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5468                 } else {
5469                         r->default_datatype = NULL;
5470                 }
5471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5473                 if (_ptr_dependent_files) {
5474                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5475                 } else {
5476                         r->dependent_files = NULL;
5477                 }
5478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5480                 if (_ptr_previous_names) {
5481                         NDR_PULL_ALLOC(ndr, r->previous_names);
5482                 } else {
5483                         r->previous_names = NULL;
5484                 }
5485         }
5486         if (ndr_flags & NDR_BUFFERS) {
5487                 if (r->driver_name) {
5488                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5489                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5490                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5491                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5492                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5493                                 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));
5494                         }
5495                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5496                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5498                 }
5499                 if (r->architecture) {
5500                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5501                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5503                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5504                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5505                                 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));
5506                         }
5507                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5508                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5509                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5510                 }
5511                 if (r->driver_path) {
5512                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5513                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5516                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5517                                 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));
5518                         }
5519                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5520                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5522                 }
5523                 if (r->data_file) {
5524                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5525                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5528                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5529                                 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));
5530                         }
5531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5532                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5534                 }
5535                 if (r->config_file) {
5536                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5537                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5540                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5541                                 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));
5542                         }
5543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5546                 }
5547                 if (r->help_file) {
5548                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5549                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5552                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5553                                 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));
5554                         }
5555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5558                 }
5559                 if (r->monitor_name) {
5560                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5561                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5564                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5565                                 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));
5566                         }
5567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5570                 }
5571                 if (r->default_datatype) {
5572                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5573                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5574                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5575                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5576                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5577                                 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));
5578                         }
5579                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5580                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5581                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5582                 }
5583                 if (r->dependent_files) {
5584                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5585                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5586                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5587                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5588                 }
5589                 if (r->previous_names) {
5590                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5591                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
5592                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
5594                 }
5595         }
5596         return NDR_ERR_SUCCESS;
5597 }
5598
5599 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
5600 {
5601         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
5602         ndr->depth++;
5603         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5604         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5605         ndr->depth++;
5606         if (r->driver_name) {
5607                 ndr_print_string(ndr, "driver_name", r->driver_name);
5608         }
5609         ndr->depth--;
5610         ndr_print_ptr(ndr, "architecture", r->architecture);
5611         ndr->depth++;
5612         if (r->architecture) {
5613                 ndr_print_string(ndr, "architecture", r->architecture);
5614         }
5615         ndr->depth--;
5616         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5617         ndr->depth++;
5618         if (r->driver_path) {
5619                 ndr_print_string(ndr, "driver_path", r->driver_path);
5620         }
5621         ndr->depth--;
5622         ndr_print_ptr(ndr, "data_file", r->data_file);
5623         ndr->depth++;
5624         if (r->data_file) {
5625                 ndr_print_string(ndr, "data_file", r->data_file);
5626         }
5627         ndr->depth--;
5628         ndr_print_ptr(ndr, "config_file", r->config_file);
5629         ndr->depth++;
5630         if (r->config_file) {
5631                 ndr_print_string(ndr, "config_file", r->config_file);
5632         }
5633         ndr->depth--;
5634         ndr_print_ptr(ndr, "help_file", r->help_file);
5635         ndr->depth++;
5636         if (r->help_file) {
5637                 ndr_print_string(ndr, "help_file", r->help_file);
5638         }
5639         ndr->depth--;
5640         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5641         ndr->depth++;
5642         if (r->monitor_name) {
5643                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5644         }
5645         ndr->depth--;
5646         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5647         ndr->depth++;
5648         if (r->default_datatype) {
5649                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5650         }
5651         ndr->depth--;
5652         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);
5653         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5654         ndr->depth++;
5655         if (r->dependent_files) {
5656                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5657         }
5658         ndr->depth--;
5659         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);
5660         ndr_print_ptr(ndr, "previous_names", r->previous_names);
5661         ndr->depth++;
5662         if (r->previous_names) {
5663                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
5664         }
5665         ndr->depth--;
5666         ndr->depth--;
5667 }
5668
5669 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
5670 {
5671         if (ndr_flags & NDR_SCALARS) {
5672                 NDR_CHECK(ndr_push_align(ndr, 8));
5673                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5683                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5686                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
5687                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
5688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
5689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
5690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
5691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
5692         }
5693         if (ndr_flags & NDR_BUFFERS) {
5694                 if (r->driver_name) {
5695                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5698                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5699                 }
5700                 if (r->architecture) {
5701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5704                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5705                 }
5706                 if (r->driver_path) {
5707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5710                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5711                 }
5712                 if (r->data_file) {
5713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5717                 }
5718                 if (r->config_file) {
5719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5723                 }
5724                 if (r->help_file) {
5725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5728                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5729                 }
5730                 if (r->monitor_name) {
5731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5734                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5735                 }
5736                 if (r->default_datatype) {
5737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5740                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5741                 }
5742                 if (r->dependent_files) {
5743                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5744                 }
5745                 if (r->previous_names) {
5746                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5747                 }
5748                 if (r->manufacturer_name) {
5749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5750                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5752                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5753                 }
5754                 if (r->manufacturer_url) {
5755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5758                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5759                 }
5760                 if (r->hardware_id) {
5761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5764                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5765                 }
5766                 if (r->provider) {
5767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5770                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5771                 }
5772         }
5773         return NDR_ERR_SUCCESS;
5774 }
5775
5776 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
5777 {
5778         uint32_t _ptr_driver_name;
5779         TALLOC_CTX *_mem_save_driver_name_0;
5780         uint32_t _ptr_architecture;
5781         TALLOC_CTX *_mem_save_architecture_0;
5782         uint32_t _ptr_driver_path;
5783         TALLOC_CTX *_mem_save_driver_path_0;
5784         uint32_t _ptr_data_file;
5785         TALLOC_CTX *_mem_save_data_file_0;
5786         uint32_t _ptr_config_file;
5787         TALLOC_CTX *_mem_save_config_file_0;
5788         uint32_t _ptr_help_file;
5789         TALLOC_CTX *_mem_save_help_file_0;
5790         uint32_t _ptr_monitor_name;
5791         TALLOC_CTX *_mem_save_monitor_name_0;
5792         uint32_t _ptr_default_datatype;
5793         TALLOC_CTX *_mem_save_default_datatype_0;
5794         uint32_t _ptr_dependent_files;
5795         TALLOC_CTX *_mem_save_dependent_files_0;
5796         uint32_t _ptr_previous_names;
5797         TALLOC_CTX *_mem_save_previous_names_0;
5798         uint32_t _ptr_manufacturer_name;
5799         TALLOC_CTX *_mem_save_manufacturer_name_0;
5800         uint32_t _ptr_manufacturer_url;
5801         TALLOC_CTX *_mem_save_manufacturer_url_0;
5802         uint32_t _ptr_hardware_id;
5803         TALLOC_CTX *_mem_save_hardware_id_0;
5804         uint32_t _ptr_provider;
5805         TALLOC_CTX *_mem_save_provider_0;
5806         if (ndr_flags & NDR_SCALARS) {
5807                 NDR_CHECK(ndr_pull_align(ndr, 8));
5808                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5810                 if (_ptr_driver_name) {
5811                         NDR_PULL_ALLOC(ndr, r->driver_name);
5812                 } else {
5813                         r->driver_name = NULL;
5814                 }
5815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5816                 if (_ptr_architecture) {
5817                         NDR_PULL_ALLOC(ndr, r->architecture);
5818                 } else {
5819                         r->architecture = NULL;
5820                 }
5821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5822                 if (_ptr_driver_path) {
5823                         NDR_PULL_ALLOC(ndr, r->driver_path);
5824                 } else {
5825                         r->driver_path = NULL;
5826                 }
5827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5828                 if (_ptr_data_file) {
5829                         NDR_PULL_ALLOC(ndr, r->data_file);
5830                 } else {
5831                         r->data_file = NULL;
5832                 }
5833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5834                 if (_ptr_config_file) {
5835                         NDR_PULL_ALLOC(ndr, r->config_file);
5836                 } else {
5837                         r->config_file = NULL;
5838                 }
5839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5840                 if (_ptr_help_file) {
5841                         NDR_PULL_ALLOC(ndr, r->help_file);
5842                 } else {
5843                         r->help_file = NULL;
5844                 }
5845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5846                 if (_ptr_monitor_name) {
5847                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5848                 } else {
5849                         r->monitor_name = NULL;
5850                 }
5851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5852                 if (_ptr_default_datatype) {
5853                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5854                 } else {
5855                         r->default_datatype = NULL;
5856                 }
5857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5859                 if (_ptr_dependent_files) {
5860                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5861                 } else {
5862                         r->dependent_files = NULL;
5863                 }
5864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5866                 if (_ptr_previous_names) {
5867                         NDR_PULL_ALLOC(ndr, r->previous_names);
5868                 } else {
5869                         r->previous_names = NULL;
5870                 }
5871                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
5872                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
5873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
5874                 if (_ptr_manufacturer_name) {
5875                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
5876                 } else {
5877                         r->manufacturer_name = NULL;
5878                 }
5879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
5880                 if (_ptr_manufacturer_url) {
5881                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
5882                 } else {
5883                         r->manufacturer_url = NULL;
5884                 }
5885                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
5886                 if (_ptr_hardware_id) {
5887                         NDR_PULL_ALLOC(ndr, r->hardware_id);
5888                 } else {
5889                         r->hardware_id = NULL;
5890                 }
5891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
5892                 if (_ptr_provider) {
5893                         NDR_PULL_ALLOC(ndr, r->provider);
5894                 } else {
5895                         r->provider = NULL;
5896                 }
5897         }
5898         if (ndr_flags & NDR_BUFFERS) {
5899                 if (r->driver_name) {
5900                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5901                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5902                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5903                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5904                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5905                                 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));
5906                         }
5907                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5908                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5910                 }
5911                 if (r->architecture) {
5912                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5913                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5914                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5915                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5916                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5917                                 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));
5918                         }
5919                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5920                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5922                 }
5923                 if (r->driver_path) {
5924                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5925                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5926                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5927                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5928                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5929                                 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));
5930                         }
5931                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5932                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5934                 }
5935                 if (r->data_file) {
5936                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5937                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5938                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5939                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5940                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5941                                 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));
5942                         }
5943                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5944                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5945                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5946                 }
5947                 if (r->config_file) {
5948                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5949                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5952                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5953                                 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));
5954                         }
5955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5958                 }
5959                 if (r->help_file) {
5960                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5961                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5962                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5963                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5964                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5965                                 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));
5966                         }
5967                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5968                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5970                 }
5971                 if (r->monitor_name) {
5972                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5973                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5974                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5975                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5976                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5977                                 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));
5978                         }
5979                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5980                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5981                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5982                 }
5983                 if (r->default_datatype) {
5984                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5985                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5986                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5987                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5988                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5989                                 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));
5990                         }
5991                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5992                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5993                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5994                 }
5995                 if (r->dependent_files) {
5996                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5997                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5998                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6000                 }
6001                 if (r->previous_names) {
6002                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6003                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6004                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6006                 }
6007                 if (r->manufacturer_name) {
6008                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6009                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6010                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6011                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6012                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6013                                 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));
6014                         }
6015                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6016                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6017                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6018                 }
6019                 if (r->manufacturer_url) {
6020                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6021                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6022                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6023                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6024                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6025                                 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));
6026                         }
6027                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6028                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6030                 }
6031                 if (r->hardware_id) {
6032                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6033                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6035                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6036                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6037                                 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));
6038                         }
6039                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6040                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6042                 }
6043                 if (r->provider) {
6044                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6045                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6046                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6047                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6048                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6049                                 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));
6050                         }
6051                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6052                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6054                 }
6055         }
6056         return NDR_ERR_SUCCESS;
6057 }
6058
6059 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
6060 {
6061         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
6062         ndr->depth++;
6063         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6064         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6065         ndr->depth++;
6066         if (r->driver_name) {
6067                 ndr_print_string(ndr, "driver_name", r->driver_name);
6068         }
6069         ndr->depth--;
6070         ndr_print_ptr(ndr, "architecture", r->architecture);
6071         ndr->depth++;
6072         if (r->architecture) {
6073                 ndr_print_string(ndr, "architecture", r->architecture);
6074         }
6075         ndr->depth--;
6076         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6077         ndr->depth++;
6078         if (r->driver_path) {
6079                 ndr_print_string(ndr, "driver_path", r->driver_path);
6080         }
6081         ndr->depth--;
6082         ndr_print_ptr(ndr, "data_file", r->data_file);
6083         ndr->depth++;
6084         if (r->data_file) {
6085                 ndr_print_string(ndr, "data_file", r->data_file);
6086         }
6087         ndr->depth--;
6088         ndr_print_ptr(ndr, "config_file", r->config_file);
6089         ndr->depth++;
6090         if (r->config_file) {
6091                 ndr_print_string(ndr, "config_file", r->config_file);
6092         }
6093         ndr->depth--;
6094         ndr_print_ptr(ndr, "help_file", r->help_file);
6095         ndr->depth++;
6096         if (r->help_file) {
6097                 ndr_print_string(ndr, "help_file", r->help_file);
6098         }
6099         ndr->depth--;
6100         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6101         ndr->depth++;
6102         if (r->monitor_name) {
6103                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6104         }
6105         ndr->depth--;
6106         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6107         ndr->depth++;
6108         if (r->default_datatype) {
6109                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6110         }
6111         ndr->depth--;
6112         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);
6113         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6114         ndr->depth++;
6115         if (r->dependent_files) {
6116                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6117         }
6118         ndr->depth--;
6119         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);
6120         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6121         ndr->depth++;
6122         if (r->previous_names) {
6123                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6124         }
6125         ndr->depth--;
6126         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
6127         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6128         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6129         ndr->depth++;
6130         if (r->manufacturer_name) {
6131                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6132         }
6133         ndr->depth--;
6134         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6135         ndr->depth++;
6136         if (r->manufacturer_url) {
6137                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6138         }
6139         ndr->depth--;
6140         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6141         ndr->depth++;
6142         if (r->hardware_id) {
6143                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6144         }
6145         ndr->depth--;
6146         ndr_print_ptr(ndr, "provider", r->provider);
6147         ndr->depth++;
6148         if (r->provider) {
6149                 ndr_print_string(ndr, "provider", r->provider);
6150         }
6151         ndr->depth--;
6152         ndr->depth--;
6153 }
6154
6155 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
6156 {
6157         if (ndr_flags & NDR_SCALARS) {
6158                 NDR_CHECK(ndr_push_align(ndr, 8));
6159                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6162                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
6166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
6167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
6168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6169                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
6170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
6172                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
6173                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
6174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
6175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
6176                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
6177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
6178                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
6179                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
6180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
6182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
6183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
6184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
6186                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
6187                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
6188         }
6189         if (ndr_flags & NDR_BUFFERS) {
6190                 if (r->driver_name) {
6191                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6192                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6194                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6195                 }
6196                 if (r->architecture) {
6197                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6200                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6201                 }
6202                 if (r->driver_path) {
6203                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6204                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6205                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6206                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6207                 }
6208                 if (r->data_file) {
6209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6211                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6212                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6213                 }
6214                 if (r->config_file) {
6215                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6218                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6219                 }
6220                 if (r->help_file) {
6221                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6223                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6224                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6225                 }
6226                 if (r->monitor_name) {
6227                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6228                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6229                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6230                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6231                 }
6232                 if (r->default_datatype) {
6233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6234                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6235                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6236                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6237                 }
6238                 if (r->dependent_files) {
6239                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6240                 }
6241                 if (r->previous_names) {
6242                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6243                 }
6244                 if (r->manufacturer_name) {
6245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6248                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6249                 }
6250                 if (r->manufacturer_url) {
6251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6252                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6253                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6254                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6255                 }
6256                 if (r->hardware_id) {
6257                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6258                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6260                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6261                 }
6262                 if (r->provider) {
6263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6266                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6267                 }
6268                 if (r->print_processor) {
6269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6270                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6272                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6273                 }
6274                 if (r->vendor_setup) {
6275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6276                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6277                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6278                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6279                 }
6280                 if (r->color_profiles) {
6281                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6282                 }
6283                 if (r->inf_path) {
6284                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6286                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6288                 }
6289                 if (r->core_driver_dependencies) {
6290                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6291                 }
6292         }
6293         return NDR_ERR_SUCCESS;
6294 }
6295
6296 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
6297 {
6298         uint32_t _ptr_driver_name;
6299         TALLOC_CTX *_mem_save_driver_name_0;
6300         uint32_t _ptr_architecture;
6301         TALLOC_CTX *_mem_save_architecture_0;
6302         uint32_t _ptr_driver_path;
6303         TALLOC_CTX *_mem_save_driver_path_0;
6304         uint32_t _ptr_data_file;
6305         TALLOC_CTX *_mem_save_data_file_0;
6306         uint32_t _ptr_config_file;
6307         TALLOC_CTX *_mem_save_config_file_0;
6308         uint32_t _ptr_help_file;
6309         TALLOC_CTX *_mem_save_help_file_0;
6310         uint32_t _ptr_monitor_name;
6311         TALLOC_CTX *_mem_save_monitor_name_0;
6312         uint32_t _ptr_default_datatype;
6313         TALLOC_CTX *_mem_save_default_datatype_0;
6314         uint32_t _ptr_dependent_files;
6315         TALLOC_CTX *_mem_save_dependent_files_0;
6316         uint32_t _ptr_previous_names;
6317         TALLOC_CTX *_mem_save_previous_names_0;
6318         uint32_t _ptr_manufacturer_name;
6319         TALLOC_CTX *_mem_save_manufacturer_name_0;
6320         uint32_t _ptr_manufacturer_url;
6321         TALLOC_CTX *_mem_save_manufacturer_url_0;
6322         uint32_t _ptr_hardware_id;
6323         TALLOC_CTX *_mem_save_hardware_id_0;
6324         uint32_t _ptr_provider;
6325         TALLOC_CTX *_mem_save_provider_0;
6326         uint32_t _ptr_print_processor;
6327         TALLOC_CTX *_mem_save_print_processor_0;
6328         uint32_t _ptr_vendor_setup;
6329         TALLOC_CTX *_mem_save_vendor_setup_0;
6330         uint32_t _ptr_color_profiles;
6331         TALLOC_CTX *_mem_save_color_profiles_0;
6332         uint32_t _ptr_inf_path;
6333         TALLOC_CTX *_mem_save_inf_path_0;
6334         uint32_t _ptr_core_driver_dependencies;
6335         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
6336         if (ndr_flags & NDR_SCALARS) {
6337                 NDR_CHECK(ndr_pull_align(ndr, 8));
6338                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6339                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6340                 if (_ptr_driver_name) {
6341                         NDR_PULL_ALLOC(ndr, r->driver_name);
6342                 } else {
6343                         r->driver_name = NULL;
6344                 }
6345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6346                 if (_ptr_architecture) {
6347                         NDR_PULL_ALLOC(ndr, r->architecture);
6348                 } else {
6349                         r->architecture = NULL;
6350                 }
6351                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6352                 if (_ptr_driver_path) {
6353                         NDR_PULL_ALLOC(ndr, r->driver_path);
6354                 } else {
6355                         r->driver_path = NULL;
6356                 }
6357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6358                 if (_ptr_data_file) {
6359                         NDR_PULL_ALLOC(ndr, r->data_file);
6360                 } else {
6361                         r->data_file = NULL;
6362                 }
6363                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6364                 if (_ptr_config_file) {
6365                         NDR_PULL_ALLOC(ndr, r->config_file);
6366                 } else {
6367                         r->config_file = NULL;
6368                 }
6369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
6370                 if (_ptr_help_file) {
6371                         NDR_PULL_ALLOC(ndr, r->help_file);
6372                 } else {
6373                         r->help_file = NULL;
6374                 }
6375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
6376                 if (_ptr_monitor_name) {
6377                         NDR_PULL_ALLOC(ndr, r->monitor_name);
6378                 } else {
6379                         r->monitor_name = NULL;
6380                 }
6381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
6382                 if (_ptr_default_datatype) {
6383                         NDR_PULL_ALLOC(ndr, r->default_datatype);
6384                 } else {
6385                         r->default_datatype = NULL;
6386                 }
6387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
6388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
6389                 if (_ptr_dependent_files) {
6390                         NDR_PULL_ALLOC(ndr, r->dependent_files);
6391                 } else {
6392                         r->dependent_files = NULL;
6393                 }
6394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
6395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
6396                 if (_ptr_previous_names) {
6397                         NDR_PULL_ALLOC(ndr, r->previous_names);
6398                 } else {
6399                         r->previous_names = NULL;
6400                 }
6401                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
6402                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
6403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
6404                 if (_ptr_manufacturer_name) {
6405                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
6406                 } else {
6407                         r->manufacturer_name = NULL;
6408                 }
6409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
6410                 if (_ptr_manufacturer_url) {
6411                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
6412                 } else {
6413                         r->manufacturer_url = NULL;
6414                 }
6415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
6416                 if (_ptr_hardware_id) {
6417                         NDR_PULL_ALLOC(ndr, r->hardware_id);
6418                 } else {
6419                         r->hardware_id = NULL;
6420                 }
6421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
6422                 if (_ptr_provider) {
6423                         NDR_PULL_ALLOC(ndr, r->provider);
6424                 } else {
6425                         r->provider = NULL;
6426                 }
6427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
6428                 if (_ptr_print_processor) {
6429                         NDR_PULL_ALLOC(ndr, r->print_processor);
6430                 } else {
6431                         r->print_processor = NULL;
6432                 }
6433                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
6434                 if (_ptr_vendor_setup) {
6435                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
6436                 } else {
6437                         r->vendor_setup = NULL;
6438                 }
6439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
6440                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
6441                 if (_ptr_color_profiles) {
6442                         NDR_PULL_ALLOC(ndr, r->color_profiles);
6443                 } else {
6444                         r->color_profiles = NULL;
6445                 }
6446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
6447                 if (_ptr_inf_path) {
6448                         NDR_PULL_ALLOC(ndr, r->inf_path);
6449                 } else {
6450                         r->inf_path = NULL;
6451                 }
6452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
6453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
6454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
6455                 if (_ptr_core_driver_dependencies) {
6456                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
6457                 } else {
6458                         r->core_driver_dependencies = NULL;
6459                 }
6460                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
6461                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
6462         }
6463         if (ndr_flags & NDR_BUFFERS) {
6464                 if (r->driver_name) {
6465                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6466                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6467                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6468                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6469                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6470                                 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));
6471                         }
6472                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6473                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6475                 }
6476                 if (r->architecture) {
6477                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6478                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6479                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6480                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6481                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6482                                 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));
6483                         }
6484                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6485                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6487                 }
6488                 if (r->driver_path) {
6489                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6490                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6491                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6492                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6493                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6494                                 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));
6495                         }
6496                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6497                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6499                 }
6500                 if (r->data_file) {
6501                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6502                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6503                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6504                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6505                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6506                                 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));
6507                         }
6508                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6509                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6511                 }
6512                 if (r->config_file) {
6513                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6514                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6517                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6518                                 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));
6519                         }
6520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6523                 }
6524                 if (r->help_file) {
6525                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6526                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
6527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
6528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
6529                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
6530                                 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));
6531                         }
6532                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
6533                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
6534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
6535                 }
6536                 if (r->monitor_name) {
6537                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6538                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6541                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6542                                 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));
6543                         }
6544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6547                 }
6548                 if (r->default_datatype) {
6549                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6550                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6552                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6553                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6554                                 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));
6555                         }
6556                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6557                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6559                 }
6560                 if (r->dependent_files) {
6561                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6562                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6563                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6565                 }
6566                 if (r->previous_names) {
6567                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6568                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6569                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6571                 }
6572                 if (r->manufacturer_name) {
6573                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6574                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6575                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6576                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6577                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6578                                 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));
6579                         }
6580                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6581                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6583                 }
6584                 if (r->manufacturer_url) {
6585                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6586                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6589                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6590                                 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));
6591                         }
6592                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6593                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6595                 }
6596                 if (r->hardware_id) {
6597                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6598                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6599                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6600                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6601                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6602                                 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));
6603                         }
6604                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6605                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6607                 }
6608                 if (r->provider) {
6609                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6610                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6611                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6612                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6613                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6614                                 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));
6615                         }
6616                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6617                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6618                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6619                 }
6620                 if (r->print_processor) {
6621                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6622                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6623                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6624                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6625                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6626                                 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));
6627                         }
6628                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6629                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6631                 }
6632                 if (r->vendor_setup) {
6633                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
6634                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
6635                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
6636                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
6637                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
6638                                 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));
6639                         }
6640                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
6641                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
6642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
6643                 }
6644                 if (r->color_profiles) {
6645                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
6646                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
6647                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6648                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
6649                 }
6650                 if (r->inf_path) {
6651                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6652                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
6653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
6654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
6655                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
6656                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
6657                         }
6658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
6659                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
6660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
6661                 }
6662                 if (r->core_driver_dependencies) {
6663                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
6664                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
6665                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
6667                 }
6668         }
6669         return NDR_ERR_SUCCESS;
6670 }
6671
6672 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
6673 {
6674         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
6675         ndr->depth++;
6676         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6677         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6678         ndr->depth++;
6679         if (r->driver_name) {
6680                 ndr_print_string(ndr, "driver_name", r->driver_name);
6681         }
6682         ndr->depth--;
6683         ndr_print_ptr(ndr, "architecture", r->architecture);
6684         ndr->depth++;
6685         if (r->architecture) {
6686                 ndr_print_string(ndr, "architecture", r->architecture);
6687         }
6688         ndr->depth--;
6689         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6690         ndr->depth++;
6691         if (r->driver_path) {
6692                 ndr_print_string(ndr, "driver_path", r->driver_path);
6693         }
6694         ndr->depth--;
6695         ndr_print_ptr(ndr, "data_file", r->data_file);
6696         ndr->depth++;
6697         if (r->data_file) {
6698                 ndr_print_string(ndr, "data_file", r->data_file);
6699         }
6700         ndr->depth--;
6701         ndr_print_ptr(ndr, "config_file", r->config_file);
6702         ndr->depth++;
6703         if (r->config_file) {
6704                 ndr_print_string(ndr, "config_file", r->config_file);
6705         }
6706         ndr->depth--;
6707         ndr_print_ptr(ndr, "help_file", r->help_file);
6708         ndr->depth++;
6709         if (r->help_file) {
6710                 ndr_print_string(ndr, "help_file", r->help_file);
6711         }
6712         ndr->depth--;
6713         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6714         ndr->depth++;
6715         if (r->monitor_name) {
6716                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6717         }
6718         ndr->depth--;
6719         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6720         ndr->depth++;
6721         if (r->default_datatype) {
6722                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6723         }
6724         ndr->depth--;
6725         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);
6726         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6727         ndr->depth++;
6728         if (r->dependent_files) {
6729                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6730         }
6731         ndr->depth--;
6732         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);
6733         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6734         ndr->depth++;
6735         if (r->previous_names) {
6736                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6737         }
6738         ndr->depth--;
6739         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
6740         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6741         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6742         ndr->depth++;
6743         if (r->manufacturer_name) {
6744                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6745         }
6746         ndr->depth--;
6747         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6748         ndr->depth++;
6749         if (r->manufacturer_url) {
6750                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6751         }
6752         ndr->depth--;
6753         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6754         ndr->depth++;
6755         if (r->hardware_id) {
6756                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6757         }
6758         ndr->depth--;
6759         ndr_print_ptr(ndr, "provider", r->provider);
6760         ndr->depth++;
6761         if (r->provider) {
6762                 ndr_print_string(ndr, "provider", r->provider);
6763         }
6764         ndr->depth--;
6765         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6766         ndr->depth++;
6767         if (r->print_processor) {
6768                 ndr_print_string(ndr, "print_processor", r->print_processor);
6769         }
6770         ndr->depth--;
6771         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
6772         ndr->depth++;
6773         if (r->vendor_setup) {
6774                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
6775         }
6776         ndr->depth--;
6777         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);
6778         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
6779         ndr->depth++;
6780         if (r->color_profiles) {
6781                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
6782         }
6783         ndr->depth--;
6784         ndr_print_ptr(ndr, "inf_path", r->inf_path);
6785         ndr->depth++;
6786         if (r->inf_path) {
6787                 ndr_print_string(ndr, "inf_path", r->inf_path);
6788         }
6789         ndr->depth--;
6790         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
6791         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);
6792         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6793         ndr->depth++;
6794         if (r->core_driver_dependencies) {
6795                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6796         }
6797         ndr->depth--;
6798         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
6799         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
6800         ndr->depth--;
6801 }
6802
6803 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
6804 {
6805         if (ndr_flags & NDR_SCALARS) {
6806                 int level = ndr_push_get_switch_value(ndr, r);
6807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6808                 switch (level) {
6809                         case 1: {
6810                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6811                         break; }
6812
6813                         case 2: {
6814                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6815                         break; }
6816
6817                         case 3: {
6818                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6819                         break; }
6820
6821                         case 4: {
6822                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6823                         break; }
6824
6825                         case 6: {
6826                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6827                         break; }
6828
6829                         case 8: {
6830                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6831                         break; }
6832
6833                         default:
6834                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6835                 }
6836         }
6837         if (ndr_flags & NDR_BUFFERS) {
6838                 int level = ndr_push_get_switch_value(ndr, r);
6839                 switch (level) {
6840                         case 1:
6841                                 if (r->info1) {
6842                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6843                                 }
6844                         break;
6845
6846                         case 2:
6847                                 if (r->info2) {
6848                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6849                                 }
6850                         break;
6851
6852                         case 3:
6853                                 if (r->info3) {
6854                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6855                                 }
6856                         break;
6857
6858                         case 4:
6859                                 if (r->info4) {
6860                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6861                                 }
6862                         break;
6863
6864                         case 6:
6865                                 if (r->info6) {
6866                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
6867                                 }
6868                         break;
6869
6870                         case 8:
6871                                 if (r->info8) {
6872                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6873                                 }
6874                         break;
6875
6876                         default:
6877                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6878                 }
6879         }
6880         return NDR_ERR_SUCCESS;
6881 }
6882
6883 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
6884 {
6885         int level;
6886         uint32_t _level;
6887         TALLOC_CTX *_mem_save_info1_0;
6888         TALLOC_CTX *_mem_save_info2_0;
6889         TALLOC_CTX *_mem_save_info3_0;
6890         TALLOC_CTX *_mem_save_info4_0;
6891         TALLOC_CTX *_mem_save_info6_0;
6892         TALLOC_CTX *_mem_save_info8_0;
6893         level = ndr_pull_get_switch_value(ndr, r);
6894         if (ndr_flags & NDR_SCALARS) {
6895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6896                 if (_level != level) {
6897                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6898                 }
6899                 switch (level) {
6900                         case 1: {
6901                                 uint32_t _ptr_info1;
6902                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6903                                 if (_ptr_info1) {
6904                                         NDR_PULL_ALLOC(ndr, r->info1);
6905                                 } else {
6906                                         r->info1 = NULL;
6907                                 }
6908                         break; }
6909
6910                         case 2: {
6911                                 uint32_t _ptr_info2;
6912                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6913                                 if (_ptr_info2) {
6914                                         NDR_PULL_ALLOC(ndr, r->info2);
6915                                 } else {
6916                                         r->info2 = NULL;
6917                                 }
6918                         break; }
6919
6920                         case 3: {
6921                                 uint32_t _ptr_info3;
6922                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6923                                 if (_ptr_info3) {
6924                                         NDR_PULL_ALLOC(ndr, r->info3);
6925                                 } else {
6926                                         r->info3 = NULL;
6927                                 }
6928                         break; }
6929
6930                         case 4: {
6931                                 uint32_t _ptr_info4;
6932                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6933                                 if (_ptr_info4) {
6934                                         NDR_PULL_ALLOC(ndr, r->info4);
6935                                 } else {
6936                                         r->info4 = NULL;
6937                                 }
6938                         break; }
6939
6940                         case 6: {
6941                                 uint32_t _ptr_info6;
6942                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
6943                                 if (_ptr_info6) {
6944                                         NDR_PULL_ALLOC(ndr, r->info6);
6945                                 } else {
6946                                         r->info6 = NULL;
6947                                 }
6948                         break; }
6949
6950                         case 8: {
6951                                 uint32_t _ptr_info8;
6952                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
6953                                 if (_ptr_info8) {
6954                                         NDR_PULL_ALLOC(ndr, r->info8);
6955                                 } else {
6956                                         r->info8 = NULL;
6957                                 }
6958                         break; }
6959
6960                         default:
6961                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6962                 }
6963         }
6964         if (ndr_flags & NDR_BUFFERS) {
6965                 switch (level) {
6966                         case 1:
6967                                 if (r->info1) {
6968                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6969                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6970                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6971                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6972                                 }
6973                         break;
6974
6975                         case 2:
6976                                 if (r->info2) {
6977                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6978                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6979                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6980                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6981                                 }
6982                         break;
6983
6984                         case 3:
6985                                 if (r->info3) {
6986                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6987                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6988                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6989                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6990                                 }
6991                         break;
6992
6993                         case 4:
6994                                 if (r->info4) {
6995                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6996                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6997                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6998                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6999                                 }
7000                         break;
7001
7002                         case 6:
7003                                 if (r->info6) {
7004                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7005                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7006                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
7007                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7008                                 }
7009                         break;
7010
7011                         case 8:
7012                                 if (r->info8) {
7013                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7014                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7015                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7016                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7017                                 }
7018                         break;
7019
7020                         default:
7021                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7022                 }
7023         }
7024         return NDR_ERR_SUCCESS;
7025 }
7026
7027 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
7028 {
7029         int level;
7030         level = ndr_print_get_switch_value(ndr, r);
7031         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
7032         switch (level) {
7033                 case 1:
7034                         ndr_print_ptr(ndr, "info1", r->info1);
7035                         ndr->depth++;
7036                         if (r->info1) {
7037                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
7038                         }
7039                         ndr->depth--;
7040                 break;
7041
7042                 case 2:
7043                         ndr_print_ptr(ndr, "info2", r->info2);
7044                         ndr->depth++;
7045                         if (r->info2) {
7046                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
7047                         }
7048                         ndr->depth--;
7049                 break;
7050
7051                 case 3:
7052                         ndr_print_ptr(ndr, "info3", r->info3);
7053                         ndr->depth++;
7054                         if (r->info3) {
7055                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
7056                         }
7057                         ndr->depth--;
7058                 break;
7059
7060                 case 4:
7061                         ndr_print_ptr(ndr, "info4", r->info4);
7062                         ndr->depth++;
7063                         if (r->info4) {
7064                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
7065                         }
7066                         ndr->depth--;
7067                 break;
7068
7069                 case 6:
7070                         ndr_print_ptr(ndr, "info6", r->info6);
7071                         ndr->depth++;
7072                         if (r->info6) {
7073                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
7074                         }
7075                         ndr->depth--;
7076                 break;
7077
7078                 case 8:
7079                         ndr_print_ptr(ndr, "info8", r->info8);
7080                         ndr->depth++;
7081                         if (r->info8) {
7082                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
7083                         }
7084                         ndr->depth--;
7085                 break;
7086
7087                 default:
7088                         ndr_print_bad_level(ndr, name, level);
7089         }
7090 }
7091
7092 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
7093 {
7094         if (ndr_flags & NDR_SCALARS) {
7095                 NDR_CHECK(ndr_push_align(ndr, 4));
7096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7097                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7098                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7099         }
7100         if (ndr_flags & NDR_BUFFERS) {
7101                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7102         }
7103         return NDR_ERR_SUCCESS;
7104 }
7105
7106 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
7107 {
7108         if (ndr_flags & NDR_SCALARS) {
7109                 NDR_CHECK(ndr_pull_align(ndr, 4));
7110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7111                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7112                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7113         }
7114         if (ndr_flags & NDR_BUFFERS) {
7115                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7116         }
7117         return NDR_ERR_SUCCESS;
7118 }
7119
7120 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
7121 {
7122         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
7123         ndr->depth++;
7124         ndr_print_uint32(ndr, "level", r->level);
7125         ndr_print_set_switch_value(ndr, &r->info, r->level);
7126         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
7127         ndr->depth--;
7128 }
7129
7130 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
7131 {
7132         if (ndr_flags & NDR_SCALARS) {
7133                 NDR_CHECK(ndr_push_align(ndr, 4));
7134                 {
7135                         uint32_t _flags_save_string = ndr->flags;
7136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7137                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7138                         ndr->flags = _flags_save_string;
7139                 }
7140         }
7141         if (ndr_flags & NDR_BUFFERS) {
7142                 {
7143                         uint32_t _flags_save_string = ndr->flags;
7144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7145                         if (r->driver_name) {
7146                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7148                         }
7149                         ndr->flags = _flags_save_string;
7150                 }
7151         }
7152         return NDR_ERR_SUCCESS;
7153 }
7154
7155 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
7156 {
7157         uint32_t _ptr_driver_name;
7158         TALLOC_CTX *_mem_save_driver_name_0;
7159         if (ndr_flags & NDR_SCALARS) {
7160                 NDR_CHECK(ndr_pull_align(ndr, 4));
7161                 {
7162                         uint32_t _flags_save_string = ndr->flags;
7163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7164                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7165                         if (_ptr_driver_name) {
7166                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7167                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7168                         } else {
7169                                 r->driver_name = NULL;
7170                         }
7171                         ndr->flags = _flags_save_string;
7172                 }
7173         }
7174         if (ndr_flags & NDR_BUFFERS) {
7175                 {
7176                         uint32_t _flags_save_string = ndr->flags;
7177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7178                         if (r->driver_name) {
7179                                 uint32_t _relative_save_offset;
7180                                 _relative_save_offset = ndr->offset;
7181                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7182                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7183                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7184                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7185                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7186                                 ndr->offset = _relative_save_offset;
7187                         }
7188                         ndr->flags = _flags_save_string;
7189                 }
7190         }
7191         return NDR_ERR_SUCCESS;
7192 }
7193
7194 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
7195 {
7196         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
7197         ndr->depth++;
7198         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7199         ndr->depth++;
7200         if (r->driver_name) {
7201                 ndr_print_string(ndr, "driver_name", r->driver_name);
7202         }
7203         ndr->depth--;
7204         ndr->depth--;
7205 }
7206
7207 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
7208 {
7209         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
7210 }
7211
7212 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
7213 {
7214         if (ndr_flags & NDR_SCALARS) {
7215                 NDR_CHECK(ndr_push_align(ndr, 4));
7216                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7217                 {
7218                         uint32_t _flags_save_string = ndr->flags;
7219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7220                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7221                         ndr->flags = _flags_save_string;
7222                 }
7223                 {
7224                         uint32_t _flags_save_string = ndr->flags;
7225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7226                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7227                         ndr->flags = _flags_save_string;
7228                 }
7229                 {
7230                         uint32_t _flags_save_string = ndr->flags;
7231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7232                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7233                         ndr->flags = _flags_save_string;
7234                 }
7235                 {
7236                         uint32_t _flags_save_string = ndr->flags;
7237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7238                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7239                         ndr->flags = _flags_save_string;
7240                 }
7241                 {
7242                         uint32_t _flags_save_string = ndr->flags;
7243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7244                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7245                         ndr->flags = _flags_save_string;
7246                 }
7247         }
7248         if (ndr_flags & NDR_BUFFERS) {
7249                 {
7250                         uint32_t _flags_save_string = ndr->flags;
7251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7252                         if (r->driver_name) {
7253                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7254                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7255                         }
7256                         ndr->flags = _flags_save_string;
7257                 }
7258                 {
7259                         uint32_t _flags_save_string = ndr->flags;
7260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7261                         if (r->architecture) {
7262                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7263                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7264                         }
7265                         ndr->flags = _flags_save_string;
7266                 }
7267                 {
7268                         uint32_t _flags_save_string = ndr->flags;
7269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7270                         if (r->driver_path) {
7271                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7273                         }
7274                         ndr->flags = _flags_save_string;
7275                 }
7276                 {
7277                         uint32_t _flags_save_string = ndr->flags;
7278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7279                         if (r->data_file) {
7280                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7281                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7282                         }
7283                         ndr->flags = _flags_save_string;
7284                 }
7285                 {
7286                         uint32_t _flags_save_string = ndr->flags;
7287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7288                         if (r->config_file) {
7289                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7290                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7291                         }
7292                         ndr->flags = _flags_save_string;
7293                 }
7294         }
7295         return NDR_ERR_SUCCESS;
7296 }
7297
7298 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
7299 {
7300         uint32_t _ptr_driver_name;
7301         TALLOC_CTX *_mem_save_driver_name_0;
7302         uint32_t _ptr_architecture;
7303         TALLOC_CTX *_mem_save_architecture_0;
7304         uint32_t _ptr_driver_path;
7305         TALLOC_CTX *_mem_save_driver_path_0;
7306         uint32_t _ptr_data_file;
7307         TALLOC_CTX *_mem_save_data_file_0;
7308         uint32_t _ptr_config_file;
7309         TALLOC_CTX *_mem_save_config_file_0;
7310         if (ndr_flags & NDR_SCALARS) {
7311                 NDR_CHECK(ndr_pull_align(ndr, 4));
7312                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7313                 {
7314                         uint32_t _flags_save_string = ndr->flags;
7315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7316                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7317                         if (_ptr_driver_name) {
7318                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7319                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7320                         } else {
7321                                 r->driver_name = NULL;
7322                         }
7323                         ndr->flags = _flags_save_string;
7324                 }
7325                 {
7326                         uint32_t _flags_save_string = ndr->flags;
7327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7328                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7329                         if (_ptr_architecture) {
7330                                 NDR_PULL_ALLOC(ndr, r->architecture);
7331                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7332                         } else {
7333                                 r->architecture = NULL;
7334                         }
7335                         ndr->flags = _flags_save_string;
7336                 }
7337                 {
7338                         uint32_t _flags_save_string = ndr->flags;
7339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7340                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7341                         if (_ptr_driver_path) {
7342                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7343                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7344                         } else {
7345                                 r->driver_path = NULL;
7346                         }
7347                         ndr->flags = _flags_save_string;
7348                 }
7349                 {
7350                         uint32_t _flags_save_string = ndr->flags;
7351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7352                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7353                         if (_ptr_data_file) {
7354                                 NDR_PULL_ALLOC(ndr, r->data_file);
7355                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7356                         } else {
7357                                 r->data_file = NULL;
7358                         }
7359                         ndr->flags = _flags_save_string;
7360                 }
7361                 {
7362                         uint32_t _flags_save_string = ndr->flags;
7363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7364                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7365                         if (_ptr_config_file) {
7366                                 NDR_PULL_ALLOC(ndr, r->config_file);
7367                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7368                         } else {
7369                                 r->config_file = NULL;
7370                         }
7371                         ndr->flags = _flags_save_string;
7372                 }
7373         }
7374         if (ndr_flags & NDR_BUFFERS) {
7375                 {
7376                         uint32_t _flags_save_string = ndr->flags;
7377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7378                         if (r->driver_name) {
7379                                 uint32_t _relative_save_offset;
7380                                 _relative_save_offset = ndr->offset;
7381                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7382                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7383                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7384                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7385                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7386                                 ndr->offset = _relative_save_offset;
7387                         }
7388                         ndr->flags = _flags_save_string;
7389                 }
7390                 {
7391                         uint32_t _flags_save_string = ndr->flags;
7392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7393                         if (r->architecture) {
7394                                 uint32_t _relative_save_offset;
7395                                 _relative_save_offset = ndr->offset;
7396                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7397                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7398                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7399                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7400                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7401                                 ndr->offset = _relative_save_offset;
7402                         }
7403                         ndr->flags = _flags_save_string;
7404                 }
7405                 {
7406                         uint32_t _flags_save_string = ndr->flags;
7407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7408                         if (r->driver_path) {
7409                                 uint32_t _relative_save_offset;
7410                                 _relative_save_offset = ndr->offset;
7411                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7412                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7413                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7414                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7415                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7416                                 ndr->offset = _relative_save_offset;
7417                         }
7418                         ndr->flags = _flags_save_string;
7419                 }
7420                 {
7421                         uint32_t _flags_save_string = ndr->flags;
7422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7423                         if (r->data_file) {
7424                                 uint32_t _relative_save_offset;
7425                                 _relative_save_offset = ndr->offset;
7426                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7427                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7428                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7429                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7430                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7431                                 ndr->offset = _relative_save_offset;
7432                         }
7433                         ndr->flags = _flags_save_string;
7434                 }
7435                 {
7436                         uint32_t _flags_save_string = ndr->flags;
7437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7438                         if (r->config_file) {
7439                                 uint32_t _relative_save_offset;
7440                                 _relative_save_offset = ndr->offset;
7441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7442                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7443                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7446                                 ndr->offset = _relative_save_offset;
7447                         }
7448                         ndr->flags = _flags_save_string;
7449                 }
7450         }
7451         return NDR_ERR_SUCCESS;
7452 }
7453
7454 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
7455 {
7456         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
7457         ndr->depth++;
7458         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7459         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7460         ndr->depth++;
7461         if (r->driver_name) {
7462                 ndr_print_string(ndr, "driver_name", r->driver_name);
7463         }
7464         ndr->depth--;
7465         ndr_print_ptr(ndr, "architecture", r->architecture);
7466         ndr->depth++;
7467         if (r->architecture) {
7468                 ndr_print_string(ndr, "architecture", r->architecture);
7469         }
7470         ndr->depth--;
7471         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7472         ndr->depth++;
7473         if (r->driver_path) {
7474                 ndr_print_string(ndr, "driver_path", r->driver_path);
7475         }
7476         ndr->depth--;
7477         ndr_print_ptr(ndr, "data_file", r->data_file);
7478         ndr->depth++;
7479         if (r->data_file) {
7480                 ndr_print_string(ndr, "data_file", r->data_file);
7481         }
7482         ndr->depth--;
7483         ndr_print_ptr(ndr, "config_file", r->config_file);
7484         ndr->depth++;
7485         if (r->config_file) {
7486                 ndr_print_string(ndr, "config_file", r->config_file);
7487         }
7488         ndr->depth--;
7489         ndr->depth--;
7490 }
7491
7492 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
7493 {
7494         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
7495 }
7496
7497 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
7498 {
7499         if (ndr_flags & NDR_SCALARS) {
7500                 NDR_CHECK(ndr_push_align(ndr, 4));
7501                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7502                 {
7503                         uint32_t _flags_save_string = ndr->flags;
7504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7505                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7506                         ndr->flags = _flags_save_string;
7507                 }
7508                 {
7509                         uint32_t _flags_save_string = ndr->flags;
7510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7512                         ndr->flags = _flags_save_string;
7513                 }
7514                 {
7515                         uint32_t _flags_save_string = ndr->flags;
7516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7518                         ndr->flags = _flags_save_string;
7519                 }
7520                 {
7521                         uint32_t _flags_save_string = ndr->flags;
7522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7524                         ndr->flags = _flags_save_string;
7525                 }
7526                 {
7527                         uint32_t _flags_save_string = ndr->flags;
7528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7530                         ndr->flags = _flags_save_string;
7531                 }
7532                 {
7533                         uint32_t _flags_save_string = ndr->flags;
7534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
7536                         ndr->flags = _flags_save_string;
7537                 }
7538                 {
7539                         uint32_t _flags_save_string_array = ndr->flags;
7540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7541                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
7542                         ndr->flags = _flags_save_string_array;
7543                 }
7544                 {
7545                         uint32_t _flags_save_string = ndr->flags;
7546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7548                         ndr->flags = _flags_save_string;
7549                 }
7550                 {
7551                         uint32_t _flags_save_string = ndr->flags;
7552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7553                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
7554                         ndr->flags = _flags_save_string;
7555                 }
7556         }
7557         if (ndr_flags & NDR_BUFFERS) {
7558                 {
7559                         uint32_t _flags_save_string = ndr->flags;
7560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7561                         if (r->driver_name) {
7562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7564                         }
7565                         ndr->flags = _flags_save_string;
7566                 }
7567                 {
7568                         uint32_t _flags_save_string = ndr->flags;
7569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7570                         if (r->architecture) {
7571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7573                         }
7574                         ndr->flags = _flags_save_string;
7575                 }
7576                 {
7577                         uint32_t _flags_save_string = ndr->flags;
7578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7579                         if (r->driver_path) {
7580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7582                         }
7583                         ndr->flags = _flags_save_string;
7584                 }
7585                 {
7586                         uint32_t _flags_save_string = ndr->flags;
7587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7588                         if (r->data_file) {
7589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7591                         }
7592                         ndr->flags = _flags_save_string;
7593                 }
7594                 {
7595                         uint32_t _flags_save_string = ndr->flags;
7596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7597                         if (r->config_file) {
7598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7600                         }
7601                         ndr->flags = _flags_save_string;
7602                 }
7603                 {
7604                         uint32_t _flags_save_string = ndr->flags;
7605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7606                         if (r->help_file) {
7607                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
7608                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
7609                         }
7610                         ndr->flags = _flags_save_string;
7611                 }
7612                 {
7613                         uint32_t _flags_save_string_array = ndr->flags;
7614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7615                         if (r->dependent_files) {
7616                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
7617                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
7618                         }
7619                         ndr->flags = _flags_save_string_array;
7620                 }
7621                 {
7622                         uint32_t _flags_save_string = ndr->flags;
7623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7624                         if (r->monitor_name) {
7625                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7626                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7627                         }
7628                         ndr->flags = _flags_save_string;
7629                 }
7630                 {
7631                         uint32_t _flags_save_string = ndr->flags;
7632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7633                         if (r->default_datatype) {
7634                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
7635                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
7636                         }
7637                         ndr->flags = _flags_save_string;
7638                 }
7639         }
7640         return NDR_ERR_SUCCESS;
7641 }
7642
7643 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
7644 {
7645         uint32_t _ptr_driver_name;
7646         TALLOC_CTX *_mem_save_driver_name_0;
7647         uint32_t _ptr_architecture;
7648         TALLOC_CTX *_mem_save_architecture_0;
7649         uint32_t _ptr_driver_path;
7650         TALLOC_CTX *_mem_save_driver_path_0;
7651         uint32_t _ptr_data_file;
7652         TALLOC_CTX *_mem_save_data_file_0;
7653         uint32_t _ptr_config_file;
7654         TALLOC_CTX *_mem_save_config_file_0;
7655         uint32_t _ptr_help_file;
7656         TALLOC_CTX *_mem_save_help_file_0;
7657         uint32_t _ptr_dependent_files;
7658         TALLOC_CTX *_mem_save_dependent_files_0;
7659         uint32_t _ptr_monitor_name;
7660         TALLOC_CTX *_mem_save_monitor_name_0;
7661         uint32_t _ptr_default_datatype;
7662         TALLOC_CTX *_mem_save_default_datatype_0;
7663         if (ndr_flags & NDR_SCALARS) {
7664                 NDR_CHECK(ndr_pull_align(ndr, 4));
7665                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7666                 {
7667                         uint32_t _flags_save_string = ndr->flags;
7668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7669                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7670                         if (_ptr_driver_name) {
7671                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7672                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7673                         } else {
7674                                 r->driver_name = NULL;
7675                         }
7676                         ndr->flags = _flags_save_string;
7677                 }
7678                 {
7679                         uint32_t _flags_save_string = ndr->flags;
7680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7682                         if (_ptr_architecture) {
7683                                 NDR_PULL_ALLOC(ndr, r->architecture);
7684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7685                         } else {
7686                                 r->architecture = NULL;
7687                         }
7688                         ndr->flags = _flags_save_string;
7689                 }
7690                 {
7691                         uint32_t _flags_save_string = ndr->flags;
7692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7694                         if (_ptr_driver_path) {
7695                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7697                         } else {
7698                                 r->driver_path = NULL;
7699                         }
7700                         ndr->flags = _flags_save_string;
7701                 }
7702                 {
7703                         uint32_t _flags_save_string = ndr->flags;
7704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7706                         if (_ptr_data_file) {
7707                                 NDR_PULL_ALLOC(ndr, r->data_file);
7708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7709                         } else {
7710                                 r->data_file = NULL;
7711                         }
7712                         ndr->flags = _flags_save_string;
7713                 }
7714                 {
7715                         uint32_t _flags_save_string = ndr->flags;
7716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7718                         if (_ptr_config_file) {
7719                                 NDR_PULL_ALLOC(ndr, r->config_file);
7720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7721                         } else {
7722                                 r->config_file = NULL;
7723                         }
7724                         ndr->flags = _flags_save_string;
7725                 }
7726                 {
7727                         uint32_t _flags_save_string = ndr->flags;
7728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7730                         if (_ptr_help_file) {
7731                                 NDR_PULL_ALLOC(ndr, r->help_file);
7732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7733                         } else {
7734                                 r->help_file = NULL;
7735                         }
7736                         ndr->flags = _flags_save_string;
7737                 }
7738                 {
7739                         uint32_t _flags_save_string_array = ndr->flags;
7740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7742                         if (_ptr_dependent_files) {
7743                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7745                         } else {
7746                                 r->dependent_files = NULL;
7747                         }
7748                         ndr->flags = _flags_save_string_array;
7749                 }
7750                 {
7751                         uint32_t _flags_save_string = ndr->flags;
7752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7754                         if (_ptr_monitor_name) {
7755                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7757                         } else {
7758                                 r->monitor_name = NULL;
7759                         }
7760                         ndr->flags = _flags_save_string;
7761                 }
7762                 {
7763                         uint32_t _flags_save_string = ndr->flags;
7764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7766                         if (_ptr_default_datatype) {
7767                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7769                         } else {
7770                                 r->default_datatype = NULL;
7771                         }
7772                         ndr->flags = _flags_save_string;
7773                 }
7774         }
7775         if (ndr_flags & NDR_BUFFERS) {
7776                 {
7777                         uint32_t _flags_save_string = ndr->flags;
7778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7779                         if (r->driver_name) {
7780                                 uint32_t _relative_save_offset;
7781                                 _relative_save_offset = ndr->offset;
7782                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7783                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7784                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7785                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7786                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7787                                 ndr->offset = _relative_save_offset;
7788                         }
7789                         ndr->flags = _flags_save_string;
7790                 }
7791                 {
7792                         uint32_t _flags_save_string = ndr->flags;
7793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7794                         if (r->architecture) {
7795                                 uint32_t _relative_save_offset;
7796                                 _relative_save_offset = ndr->offset;
7797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7798                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7799                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7802                                 ndr->offset = _relative_save_offset;
7803                         }
7804                         ndr->flags = _flags_save_string;
7805                 }
7806                 {
7807                         uint32_t _flags_save_string = ndr->flags;
7808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7809                         if (r->driver_path) {
7810                                 uint32_t _relative_save_offset;
7811                                 _relative_save_offset = ndr->offset;
7812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7813                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7814                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7817                                 ndr->offset = _relative_save_offset;
7818                         }
7819                         ndr->flags = _flags_save_string;
7820                 }
7821                 {
7822                         uint32_t _flags_save_string = ndr->flags;
7823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7824                         if (r->data_file) {
7825                                 uint32_t _relative_save_offset;
7826                                 _relative_save_offset = ndr->offset;
7827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7828                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7829                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7832                                 ndr->offset = _relative_save_offset;
7833                         }
7834                         ndr->flags = _flags_save_string;
7835                 }
7836                 {
7837                         uint32_t _flags_save_string = ndr->flags;
7838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7839                         if (r->config_file) {
7840                                 uint32_t _relative_save_offset;
7841                                 _relative_save_offset = ndr->offset;
7842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7843                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7844                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7847                                 ndr->offset = _relative_save_offset;
7848                         }
7849                         ndr->flags = _flags_save_string;
7850                 }
7851                 {
7852                         uint32_t _flags_save_string = ndr->flags;
7853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7854                         if (r->help_file) {
7855                                 uint32_t _relative_save_offset;
7856                                 _relative_save_offset = ndr->offset;
7857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7858                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7859                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7862                                 ndr->offset = _relative_save_offset;
7863                         }
7864                         ndr->flags = _flags_save_string;
7865                 }
7866                 {
7867                         uint32_t _flags_save_string_array = ndr->flags;
7868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7869                         if (r->dependent_files) {
7870                                 uint32_t _relative_save_offset;
7871                                 _relative_save_offset = ndr->offset;
7872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7873                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7874                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7875                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7877                                 ndr->offset = _relative_save_offset;
7878                         }
7879                         ndr->flags = _flags_save_string_array;
7880                 }
7881                 {
7882                         uint32_t _flags_save_string = ndr->flags;
7883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7884                         if (r->monitor_name) {
7885                                 uint32_t _relative_save_offset;
7886                                 _relative_save_offset = ndr->offset;
7887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7888                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7889                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7892                                 ndr->offset = _relative_save_offset;
7893                         }
7894                         ndr->flags = _flags_save_string;
7895                 }
7896                 {
7897                         uint32_t _flags_save_string = ndr->flags;
7898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7899                         if (r->default_datatype) {
7900                                 uint32_t _relative_save_offset;
7901                                 _relative_save_offset = ndr->offset;
7902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7903                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7904                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7907                                 ndr->offset = _relative_save_offset;
7908                         }
7909                         ndr->flags = _flags_save_string;
7910                 }
7911         }
7912         return NDR_ERR_SUCCESS;
7913 }
7914
7915 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
7916 {
7917         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
7918         ndr->depth++;
7919         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7920         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7921         ndr->depth++;
7922         if (r->driver_name) {
7923                 ndr_print_string(ndr, "driver_name", r->driver_name);
7924         }
7925         ndr->depth--;
7926         ndr_print_ptr(ndr, "architecture", r->architecture);
7927         ndr->depth++;
7928         if (r->architecture) {
7929                 ndr_print_string(ndr, "architecture", r->architecture);
7930         }
7931         ndr->depth--;
7932         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7933         ndr->depth++;
7934         if (r->driver_path) {
7935                 ndr_print_string(ndr, "driver_path", r->driver_path);
7936         }
7937         ndr->depth--;
7938         ndr_print_ptr(ndr, "data_file", r->data_file);
7939         ndr->depth++;
7940         if (r->data_file) {
7941                 ndr_print_string(ndr, "data_file", r->data_file);
7942         }
7943         ndr->depth--;
7944         ndr_print_ptr(ndr, "config_file", r->config_file);
7945         ndr->depth++;
7946         if (r->config_file) {
7947                 ndr_print_string(ndr, "config_file", r->config_file);
7948         }
7949         ndr->depth--;
7950         ndr_print_ptr(ndr, "help_file", r->help_file);
7951         ndr->depth++;
7952         if (r->help_file) {
7953                 ndr_print_string(ndr, "help_file", r->help_file);
7954         }
7955         ndr->depth--;
7956         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7957         ndr->depth++;
7958         if (r->dependent_files) {
7959                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7960         }
7961         ndr->depth--;
7962         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7963         ndr->depth++;
7964         if (r->monitor_name) {
7965                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7966         }
7967         ndr->depth--;
7968         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7969         ndr->depth++;
7970         if (r->default_datatype) {
7971                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7972         }
7973         ndr->depth--;
7974         ndr->depth--;
7975 }
7976
7977 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
7978 {
7979         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
7980 }
7981
7982 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
7983 {
7984         if (ndr_flags & NDR_SCALARS) {
7985                 NDR_CHECK(ndr_push_align(ndr, 4));
7986                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7987                 {
7988                         uint32_t _flags_save_string = ndr->flags;
7989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7990                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7991                         ndr->flags = _flags_save_string;
7992                 }
7993                 {
7994                         uint32_t _flags_save_string = ndr->flags;
7995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7996                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7997                         ndr->flags = _flags_save_string;
7998                 }
7999                 {
8000                         uint32_t _flags_save_string = ndr->flags;
8001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8002                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8003                         ndr->flags = _flags_save_string;
8004                 }
8005                 {
8006                         uint32_t _flags_save_string = ndr->flags;
8007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8008                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8009                         ndr->flags = _flags_save_string;
8010                 }
8011                 {
8012                         uint32_t _flags_save_string = ndr->flags;
8013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8014                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8015                         ndr->flags = _flags_save_string;
8016                 }
8017                 {
8018                         uint32_t _flags_save_string = ndr->flags;
8019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8020                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8021                         ndr->flags = _flags_save_string;
8022                 }
8023                 {
8024                         uint32_t _flags_save_string_array = ndr->flags;
8025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8026                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8027                         ndr->flags = _flags_save_string_array;
8028                 }
8029                 {
8030                         uint32_t _flags_save_string = ndr->flags;
8031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8032                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8033                         ndr->flags = _flags_save_string;
8034                 }
8035                 {
8036                         uint32_t _flags_save_string = ndr->flags;
8037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8039                         ndr->flags = _flags_save_string;
8040                 }
8041                 {
8042                         uint32_t _flags_save_string_array = ndr->flags;
8043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8045                         ndr->flags = _flags_save_string_array;
8046                 }
8047         }
8048         if (ndr_flags & NDR_BUFFERS) {
8049                 {
8050                         uint32_t _flags_save_string = ndr->flags;
8051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8052                         if (r->driver_name) {
8053                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8054                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8055                         }
8056                         ndr->flags = _flags_save_string;
8057                 }
8058                 {
8059                         uint32_t _flags_save_string = ndr->flags;
8060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8061                         if (r->architecture) {
8062                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8063                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8064                         }
8065                         ndr->flags = _flags_save_string;
8066                 }
8067                 {
8068                         uint32_t _flags_save_string = ndr->flags;
8069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8070                         if (r->driver_path) {
8071                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8072                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8073                         }
8074                         ndr->flags = _flags_save_string;
8075                 }
8076                 {
8077                         uint32_t _flags_save_string = ndr->flags;
8078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8079                         if (r->data_file) {
8080                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8081                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8082                         }
8083                         ndr->flags = _flags_save_string;
8084                 }
8085                 {
8086                         uint32_t _flags_save_string = ndr->flags;
8087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8088                         if (r->config_file) {
8089                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8090                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8091                         }
8092                         ndr->flags = _flags_save_string;
8093                 }
8094                 {
8095                         uint32_t _flags_save_string = ndr->flags;
8096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8097                         if (r->help_file) {
8098                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8099                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8100                         }
8101                         ndr->flags = _flags_save_string;
8102                 }
8103                 {
8104                         uint32_t _flags_save_string_array = ndr->flags;
8105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8106                         if (r->dependent_files) {
8107                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8108                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8109                         }
8110                         ndr->flags = _flags_save_string_array;
8111                 }
8112                 {
8113                         uint32_t _flags_save_string = ndr->flags;
8114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8115                         if (r->monitor_name) {
8116                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8117                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8118                         }
8119                         ndr->flags = _flags_save_string;
8120                 }
8121                 {
8122                         uint32_t _flags_save_string = ndr->flags;
8123                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8124                         if (r->default_datatype) {
8125                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8126                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8127                         }
8128                         ndr->flags = _flags_save_string;
8129                 }
8130                 {
8131                         uint32_t _flags_save_string_array = ndr->flags;
8132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8133                         if (r->previous_names) {
8134                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8135                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8136                         }
8137                         ndr->flags = _flags_save_string_array;
8138                 }
8139         }
8140         return NDR_ERR_SUCCESS;
8141 }
8142
8143 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
8144 {
8145         uint32_t _ptr_driver_name;
8146         TALLOC_CTX *_mem_save_driver_name_0;
8147         uint32_t _ptr_architecture;
8148         TALLOC_CTX *_mem_save_architecture_0;
8149         uint32_t _ptr_driver_path;
8150         TALLOC_CTX *_mem_save_driver_path_0;
8151         uint32_t _ptr_data_file;
8152         TALLOC_CTX *_mem_save_data_file_0;
8153         uint32_t _ptr_config_file;
8154         TALLOC_CTX *_mem_save_config_file_0;
8155         uint32_t _ptr_help_file;
8156         TALLOC_CTX *_mem_save_help_file_0;
8157         uint32_t _ptr_dependent_files;
8158         TALLOC_CTX *_mem_save_dependent_files_0;
8159         uint32_t _ptr_monitor_name;
8160         TALLOC_CTX *_mem_save_monitor_name_0;
8161         uint32_t _ptr_default_datatype;
8162         TALLOC_CTX *_mem_save_default_datatype_0;
8163         uint32_t _ptr_previous_names;
8164         TALLOC_CTX *_mem_save_previous_names_0;
8165         if (ndr_flags & NDR_SCALARS) {
8166                 NDR_CHECK(ndr_pull_align(ndr, 4));
8167                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8168                 {
8169                         uint32_t _flags_save_string = ndr->flags;
8170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8171                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8172                         if (_ptr_driver_name) {
8173                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8174                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8175                         } else {
8176                                 r->driver_name = NULL;
8177                         }
8178                         ndr->flags = _flags_save_string;
8179                 }
8180                 {
8181                         uint32_t _flags_save_string = ndr->flags;
8182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8183                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8184                         if (_ptr_architecture) {
8185                                 NDR_PULL_ALLOC(ndr, r->architecture);
8186                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8187                         } else {
8188                                 r->architecture = NULL;
8189                         }
8190                         ndr->flags = _flags_save_string;
8191                 }
8192                 {
8193                         uint32_t _flags_save_string = ndr->flags;
8194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8196                         if (_ptr_driver_path) {
8197                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8199                         } else {
8200                                 r->driver_path = NULL;
8201                         }
8202                         ndr->flags = _flags_save_string;
8203                 }
8204                 {
8205                         uint32_t _flags_save_string = ndr->flags;
8206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8207                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8208                         if (_ptr_data_file) {
8209                                 NDR_PULL_ALLOC(ndr, r->data_file);
8210                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8211                         } else {
8212                                 r->data_file = NULL;
8213                         }
8214                         ndr->flags = _flags_save_string;
8215                 }
8216                 {
8217                         uint32_t _flags_save_string = ndr->flags;
8218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8220                         if (_ptr_config_file) {
8221                                 NDR_PULL_ALLOC(ndr, r->config_file);
8222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8223                         } else {
8224                                 r->config_file = NULL;
8225                         }
8226                         ndr->flags = _flags_save_string;
8227                 }
8228                 {
8229                         uint32_t _flags_save_string = ndr->flags;
8230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8231                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8232                         if (_ptr_help_file) {
8233                                 NDR_PULL_ALLOC(ndr, r->help_file);
8234                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
8235                         } else {
8236                                 r->help_file = NULL;
8237                         }
8238                         ndr->flags = _flags_save_string;
8239                 }
8240                 {
8241                         uint32_t _flags_save_string_array = ndr->flags;
8242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8243                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8244                         if (_ptr_dependent_files) {
8245                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
8246                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
8247                         } else {
8248                                 r->dependent_files = NULL;
8249                         }
8250                         ndr->flags = _flags_save_string_array;
8251                 }
8252                 {
8253                         uint32_t _flags_save_string = ndr->flags;
8254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8255                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8256                         if (_ptr_monitor_name) {
8257                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
8258                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
8259                         } else {
8260                                 r->monitor_name = NULL;
8261                         }
8262                         ndr->flags = _flags_save_string;
8263                 }
8264                 {
8265                         uint32_t _flags_save_string = ndr->flags;
8266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8267                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8268                         if (_ptr_default_datatype) {
8269                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
8270                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
8271                         } else {
8272                                 r->default_datatype = NULL;
8273                         }
8274                         ndr->flags = _flags_save_string;
8275                 }
8276                 {
8277                         uint32_t _flags_save_string_array = ndr->flags;
8278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8279                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8280                         if (_ptr_previous_names) {
8281                                 NDR_PULL_ALLOC(ndr, r->previous_names);
8282                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
8283                         } else {
8284                                 r->previous_names = NULL;
8285                         }
8286                         ndr->flags = _flags_save_string_array;
8287                 }
8288         }
8289         if (ndr_flags & NDR_BUFFERS) {
8290                 {
8291                         uint32_t _flags_save_string = ndr->flags;
8292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8293                         if (r->driver_name) {
8294                                 uint32_t _relative_save_offset;
8295                                 _relative_save_offset = ndr->offset;
8296                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8297                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8298                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8299                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8300                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8301                                 ndr->offset = _relative_save_offset;
8302                         }
8303                         ndr->flags = _flags_save_string;
8304                 }
8305                 {
8306                         uint32_t _flags_save_string = ndr->flags;
8307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8308                         if (r->architecture) {
8309                                 uint32_t _relative_save_offset;
8310                                 _relative_save_offset = ndr->offset;
8311                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8312                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8313                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8314                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8315                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8316                                 ndr->offset = _relative_save_offset;
8317                         }
8318                         ndr->flags = _flags_save_string;
8319                 }
8320                 {
8321                         uint32_t _flags_save_string = ndr->flags;
8322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8323                         if (r->driver_path) {
8324                                 uint32_t _relative_save_offset;
8325                                 _relative_save_offset = ndr->offset;
8326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8327                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8328                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8331                                 ndr->offset = _relative_save_offset;
8332                         }
8333                         ndr->flags = _flags_save_string;
8334                 }
8335                 {
8336                         uint32_t _flags_save_string = ndr->flags;
8337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8338                         if (r->data_file) {
8339                                 uint32_t _relative_save_offset;
8340                                 _relative_save_offset = ndr->offset;
8341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8342                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8343                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8346                                 ndr->offset = _relative_save_offset;
8347                         }
8348                         ndr->flags = _flags_save_string;
8349                 }
8350                 {
8351                         uint32_t _flags_save_string = ndr->flags;
8352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8353                         if (r->config_file) {
8354                                 uint32_t _relative_save_offset;
8355                                 _relative_save_offset = ndr->offset;
8356                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8357                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8358                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8359                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8360                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8361                                 ndr->offset = _relative_save_offset;
8362                         }
8363                         ndr->flags = _flags_save_string;
8364                 }
8365                 {
8366                         uint32_t _flags_save_string = ndr->flags;
8367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8368                         if (r->help_file) {
8369                                 uint32_t _relative_save_offset;
8370                                 _relative_save_offset = ndr->offset;
8371                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
8372                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8373                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8374                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
8375                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8376                                 ndr->offset = _relative_save_offset;
8377                         }
8378                         ndr->flags = _flags_save_string;
8379                 }
8380                 {
8381                         uint32_t _flags_save_string_array = ndr->flags;
8382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8383                         if (r->dependent_files) {
8384                                 uint32_t _relative_save_offset;
8385                                 _relative_save_offset = ndr->offset;
8386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
8387                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8388                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8389                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
8390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8391                                 ndr->offset = _relative_save_offset;
8392                         }
8393                         ndr->flags = _flags_save_string_array;
8394                 }
8395                 {
8396                         uint32_t _flags_save_string = ndr->flags;
8397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8398                         if (r->monitor_name) {
8399                                 uint32_t _relative_save_offset;
8400                                 _relative_save_offset = ndr->offset;
8401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
8402                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8403                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
8405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8406                                 ndr->offset = _relative_save_offset;
8407                         }
8408                         ndr->flags = _flags_save_string;
8409                 }
8410                 {
8411                         uint32_t _flags_save_string = ndr->flags;
8412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8413                         if (r->default_datatype) {
8414                                 uint32_t _relative_save_offset;
8415                                 _relative_save_offset = ndr->offset;
8416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
8417                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8418                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
8420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8421                                 ndr->offset = _relative_save_offset;
8422                         }
8423                         ndr->flags = _flags_save_string;
8424                 }
8425                 {
8426                         uint32_t _flags_save_string_array = ndr->flags;
8427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8428                         if (r->previous_names) {
8429                                 uint32_t _relative_save_offset;
8430                                 _relative_save_offset = ndr->offset;
8431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
8432                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8433                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8434                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
8435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8436                                 ndr->offset = _relative_save_offset;
8437                         }
8438                         ndr->flags = _flags_save_string_array;
8439                 }
8440         }
8441         return NDR_ERR_SUCCESS;
8442 }
8443
8444 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
8445 {
8446         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
8447         ndr->depth++;
8448         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8449         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8450         ndr->depth++;
8451         if (r->driver_name) {
8452                 ndr_print_string(ndr, "driver_name", r->driver_name);
8453         }
8454         ndr->depth--;
8455         ndr_print_ptr(ndr, "architecture", r->architecture);
8456         ndr->depth++;
8457         if (r->architecture) {
8458                 ndr_print_string(ndr, "architecture", r->architecture);
8459         }
8460         ndr->depth--;
8461         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8462         ndr->depth++;
8463         if (r->driver_path) {
8464                 ndr_print_string(ndr, "driver_path", r->driver_path);
8465         }
8466         ndr->depth--;
8467         ndr_print_ptr(ndr, "data_file", r->data_file);
8468         ndr->depth++;
8469         if (r->data_file) {
8470                 ndr_print_string(ndr, "data_file", r->data_file);
8471         }
8472         ndr->depth--;
8473         ndr_print_ptr(ndr, "config_file", r->config_file);
8474         ndr->depth++;
8475         if (r->config_file) {
8476                 ndr_print_string(ndr, "config_file", r->config_file);
8477         }
8478         ndr->depth--;
8479         ndr_print_ptr(ndr, "help_file", r->help_file);
8480         ndr->depth++;
8481         if (r->help_file) {
8482                 ndr_print_string(ndr, "help_file", r->help_file);
8483         }
8484         ndr->depth--;
8485         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8486         ndr->depth++;
8487         if (r->dependent_files) {
8488                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
8489         }
8490         ndr->depth--;
8491         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8492         ndr->depth++;
8493         if (r->monitor_name) {
8494                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8495         }
8496         ndr->depth--;
8497         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8498         ndr->depth++;
8499         if (r->default_datatype) {
8500                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8501         }
8502         ndr->depth--;
8503         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8504         ndr->depth++;
8505         if (r->previous_names) {
8506                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
8507         }
8508         ndr->depth--;
8509         ndr->depth--;
8510 }
8511
8512 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
8513 {
8514         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
8515 }
8516
8517 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
8518 {
8519         if (ndr_flags & NDR_SCALARS) {
8520                 NDR_CHECK(ndr_push_align(ndr, 4));
8521                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8522                 {
8523                         uint32_t _flags_save_string = ndr->flags;
8524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8526                         ndr->flags = _flags_save_string;
8527                 }
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->architecture));
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->driver_path));
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->data_file));
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->config_file));
8550                         ndr->flags = _flags_save_string;
8551                 }
8552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
8553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
8554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
8555         }
8556         if (ndr_flags & NDR_BUFFERS) {
8557                 {
8558                         uint32_t _flags_save_string = ndr->flags;
8559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8560                         if (r->driver_name) {
8561                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8562                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8563                         }
8564                         ndr->flags = _flags_save_string;
8565                 }
8566                 {
8567                         uint32_t _flags_save_string = ndr->flags;
8568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8569                         if (r->architecture) {
8570                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8571                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8572                         }
8573                         ndr->flags = _flags_save_string;
8574                 }
8575                 {
8576                         uint32_t _flags_save_string = ndr->flags;
8577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8578                         if (r->driver_path) {
8579                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8580                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8581                         }
8582                         ndr->flags = _flags_save_string;
8583                 }
8584                 {
8585                         uint32_t _flags_save_string = ndr->flags;
8586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8587                         if (r->data_file) {
8588                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8589                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8590                         }
8591                         ndr->flags = _flags_save_string;
8592                 }
8593                 {
8594                         uint32_t _flags_save_string = ndr->flags;
8595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8596                         if (r->config_file) {
8597                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8598                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8599                         }
8600                         ndr->flags = _flags_save_string;
8601                 }
8602         }
8603         return NDR_ERR_SUCCESS;
8604 }
8605
8606 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
8607 {
8608         uint32_t _ptr_driver_name;
8609         TALLOC_CTX *_mem_save_driver_name_0;
8610         uint32_t _ptr_architecture;
8611         TALLOC_CTX *_mem_save_architecture_0;
8612         uint32_t _ptr_driver_path;
8613         TALLOC_CTX *_mem_save_driver_path_0;
8614         uint32_t _ptr_data_file;
8615         TALLOC_CTX *_mem_save_data_file_0;
8616         uint32_t _ptr_config_file;
8617         TALLOC_CTX *_mem_save_config_file_0;
8618         if (ndr_flags & NDR_SCALARS) {
8619                 NDR_CHECK(ndr_pull_align(ndr, 4));
8620                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8621                 {
8622                         uint32_t _flags_save_string = ndr->flags;
8623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8624                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8625                         if (_ptr_driver_name) {
8626                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8627                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8628                         } else {
8629                                 r->driver_name = NULL;
8630                         }
8631                         ndr->flags = _flags_save_string;
8632                 }
8633                 {
8634                         uint32_t _flags_save_string = ndr->flags;
8635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8636                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8637                         if (_ptr_architecture) {
8638                                 NDR_PULL_ALLOC(ndr, r->architecture);
8639                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8640                         } else {
8641                                 r->architecture = NULL;
8642                         }
8643                         ndr->flags = _flags_save_string;
8644                 }
8645                 {
8646                         uint32_t _flags_save_string = ndr->flags;
8647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8648                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8649                         if (_ptr_driver_path) {
8650                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8651                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8652                         } else {
8653                                 r->driver_path = NULL;
8654                         }
8655                         ndr->flags = _flags_save_string;
8656                 }
8657                 {
8658                         uint32_t _flags_save_string = ndr->flags;
8659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8660                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8661                         if (_ptr_data_file) {
8662                                 NDR_PULL_ALLOC(ndr, r->data_file);
8663                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8664                         } else {
8665                                 r->data_file = NULL;
8666                         }
8667                         ndr->flags = _flags_save_string;
8668                 }
8669                 {
8670                         uint32_t _flags_save_string = ndr->flags;
8671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8672                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8673                         if (_ptr_config_file) {
8674                                 NDR_PULL_ALLOC(ndr, r->config_file);
8675                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8676                         } else {
8677                                 r->config_file = NULL;
8678                         }
8679                         ndr->flags = _flags_save_string;
8680                 }
8681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
8682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
8683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
8684         }
8685         if (ndr_flags & NDR_BUFFERS) {
8686                 {
8687                         uint32_t _flags_save_string = ndr->flags;
8688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8689                         if (r->driver_name) {
8690                                 uint32_t _relative_save_offset;
8691                                 _relative_save_offset = ndr->offset;
8692                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8693                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8694                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8695                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8696                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8697                                 ndr->offset = _relative_save_offset;
8698                         }
8699                         ndr->flags = _flags_save_string;
8700                 }
8701                 {
8702                         uint32_t _flags_save_string = ndr->flags;
8703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8704                         if (r->architecture) {
8705                                 uint32_t _relative_save_offset;
8706                                 _relative_save_offset = ndr->offset;
8707                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8708                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8709                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8710                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8711                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8712                                 ndr->offset = _relative_save_offset;
8713                         }
8714                         ndr->flags = _flags_save_string;
8715                 }
8716                 {
8717                         uint32_t _flags_save_string = ndr->flags;
8718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8719                         if (r->driver_path) {
8720                                 uint32_t _relative_save_offset;
8721                                 _relative_save_offset = ndr->offset;
8722                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8723                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8724                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8725                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8726                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8727                                 ndr->offset = _relative_save_offset;
8728                         }
8729                         ndr->flags = _flags_save_string;
8730                 }
8731                 {
8732                         uint32_t _flags_save_string = ndr->flags;
8733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8734                         if (r->data_file) {
8735                                 uint32_t _relative_save_offset;
8736                                 _relative_save_offset = ndr->offset;
8737                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8738                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8739                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8740                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8741                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8742                                 ndr->offset = _relative_save_offset;
8743                         }
8744                         ndr->flags = _flags_save_string;
8745                 }
8746                 {
8747                         uint32_t _flags_save_string = ndr->flags;
8748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8749                         if (r->config_file) {
8750                                 uint32_t _relative_save_offset;
8751                                 _relative_save_offset = ndr->offset;
8752                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8753                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8754                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8755                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8756                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8757                                 ndr->offset = _relative_save_offset;
8758                         }
8759                         ndr->flags = _flags_save_string;
8760                 }
8761         }
8762         return NDR_ERR_SUCCESS;
8763 }
8764
8765 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
8766 {
8767         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
8768         ndr->depth++;
8769         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8770         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8771         ndr->depth++;
8772         if (r->driver_name) {
8773                 ndr_print_string(ndr, "driver_name", r->driver_name);
8774         }
8775         ndr->depth--;
8776         ndr_print_ptr(ndr, "architecture", r->architecture);
8777         ndr->depth++;
8778         if (r->architecture) {
8779                 ndr_print_string(ndr, "architecture", r->architecture);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8783         ndr->depth++;
8784         if (r->driver_path) {
8785                 ndr_print_string(ndr, "driver_path", r->driver_path);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "data_file", r->data_file);
8789         ndr->depth++;
8790         if (r->data_file) {
8791                 ndr_print_string(ndr, "data_file", r->data_file);
8792         }
8793         ndr->depth--;
8794         ndr_print_ptr(ndr, "config_file", r->config_file);
8795         ndr->depth++;
8796         if (r->config_file) {
8797                 ndr_print_string(ndr, "config_file", r->config_file);
8798         }
8799         ndr->depth--;
8800         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
8801         ndr_print_uint32(ndr, "config_version", r->config_version);
8802         ndr_print_uint32(ndr, "driver_version", r->driver_version);
8803         ndr->depth--;
8804 }
8805
8806 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
8807 {
8808         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
8809 }
8810
8811 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
8812 {
8813         if (ndr_flags & NDR_SCALARS) {
8814                 NDR_CHECK(ndr_push_align(ndr, 8));
8815                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8816                 {
8817                         uint32_t _flags_save_string = ndr->flags;
8818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8819                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8820                         ndr->flags = _flags_save_string;
8821                 }
8822                 {
8823                         uint32_t _flags_save_string = ndr->flags;
8824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8825                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8826                         ndr->flags = _flags_save_string;
8827                 }
8828                 {
8829                         uint32_t _flags_save_string = ndr->flags;
8830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8831                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8832                         ndr->flags = _flags_save_string;
8833                 }
8834                 {
8835                         uint32_t _flags_save_string = ndr->flags;
8836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8837                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8838                         ndr->flags = _flags_save_string;
8839                 }
8840                 {
8841                         uint32_t _flags_save_string = ndr->flags;
8842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8844                         ndr->flags = _flags_save_string;
8845                 }
8846                 {
8847                         uint32_t _flags_save_string = ndr->flags;
8848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8849                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8850                         ndr->flags = _flags_save_string;
8851                 }
8852                 {
8853                         uint32_t _flags_save_string_array = ndr->flags;
8854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8855                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8856                         ndr->flags = _flags_save_string_array;
8857                 }
8858                 {
8859                         uint32_t _flags_save_string = ndr->flags;
8860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8861                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8862                         ndr->flags = _flags_save_string;
8863                 }
8864                 {
8865                         uint32_t _flags_save_string = ndr->flags;
8866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8867                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8868                         ndr->flags = _flags_save_string;
8869                 }
8870                 {
8871                         uint32_t _flags_save_string_array = ndr->flags;
8872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8873                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8874                         ndr->flags = _flags_save_string_array;
8875                 }
8876                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8877                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8878                 {
8879                         uint32_t _flags_save_string = ndr->flags;
8880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8881                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
8882                         ndr->flags = _flags_save_string;
8883                 }
8884                 {
8885                         uint32_t _flags_save_string = ndr->flags;
8886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8887                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
8888                         ndr->flags = _flags_save_string;
8889                 }
8890                 {
8891                         uint32_t _flags_save_string = ndr->flags;
8892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8893                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
8894                         ndr->flags = _flags_save_string;
8895                 }
8896                 {
8897                         uint32_t _flags_save_string = ndr->flags;
8898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8899                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
8900                         ndr->flags = _flags_save_string;
8901                 }
8902         }
8903         if (ndr_flags & NDR_BUFFERS) {
8904                 {
8905                         uint32_t _flags_save_string = ndr->flags;
8906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8907                         if (r->driver_name) {
8908                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8909                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8910                         }
8911                         ndr->flags = _flags_save_string;
8912                 }
8913                 {
8914                         uint32_t _flags_save_string = ndr->flags;
8915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8916                         if (r->architecture) {
8917                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8918                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8919                         }
8920                         ndr->flags = _flags_save_string;
8921                 }
8922                 {
8923                         uint32_t _flags_save_string = ndr->flags;
8924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8925                         if (r->driver_path) {
8926                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8927                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8928                         }
8929                         ndr->flags = _flags_save_string;
8930                 }
8931                 {
8932                         uint32_t _flags_save_string = ndr->flags;
8933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8934                         if (r->data_file) {
8935                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8936                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8937                         }
8938                         ndr->flags = _flags_save_string;
8939                 }
8940                 {
8941                         uint32_t _flags_save_string = ndr->flags;
8942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8943                         if (r->config_file) {
8944                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8945                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8946                         }
8947                         ndr->flags = _flags_save_string;
8948                 }
8949                 {
8950                         uint32_t _flags_save_string = ndr->flags;
8951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8952                         if (r->help_file) {
8953                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8955                         }
8956                         ndr->flags = _flags_save_string;
8957                 }
8958                 {
8959                         uint32_t _flags_save_string_array = ndr->flags;
8960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8961                         if (r->dependent_files) {
8962                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8963                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8964                         }
8965                         ndr->flags = _flags_save_string_array;
8966                 }
8967                 {
8968                         uint32_t _flags_save_string = ndr->flags;
8969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8970                         if (r->monitor_name) {
8971                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8972                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8973                         }
8974                         ndr->flags = _flags_save_string;
8975                 }
8976                 {
8977                         uint32_t _flags_save_string = ndr->flags;
8978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8979                         if (r->default_datatype) {
8980                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8981                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8982                         }
8983                         ndr->flags = _flags_save_string;
8984                 }
8985                 {
8986                         uint32_t _flags_save_string_array = ndr->flags;
8987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8988                         if (r->previous_names) {
8989                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8990                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8991                         }
8992                         ndr->flags = _flags_save_string_array;
8993                 }
8994                 {
8995                         uint32_t _flags_save_string = ndr->flags;
8996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8997                         if (r->manufacturer_name) {
8998                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
8999                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9000                         }
9001                         ndr->flags = _flags_save_string;
9002                 }
9003                 {
9004                         uint32_t _flags_save_string = ndr->flags;
9005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9006                         if (r->manufacturer_url) {
9007                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9008                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9009                         }
9010                         ndr->flags = _flags_save_string;
9011                 }
9012                 {
9013                         uint32_t _flags_save_string = ndr->flags;
9014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9015                         if (r->hardware_id) {
9016                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9017                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9018                         }
9019                         ndr->flags = _flags_save_string;
9020                 }
9021                 {
9022                         uint32_t _flags_save_string = ndr->flags;
9023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9024                         if (r->provider) {
9025                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9026                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9027                         }
9028                         ndr->flags = _flags_save_string;
9029                 }
9030         }
9031         return NDR_ERR_SUCCESS;
9032 }
9033
9034 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
9035 {
9036         uint32_t _ptr_driver_name;
9037         TALLOC_CTX *_mem_save_driver_name_0;
9038         uint32_t _ptr_architecture;
9039         TALLOC_CTX *_mem_save_architecture_0;
9040         uint32_t _ptr_driver_path;
9041         TALLOC_CTX *_mem_save_driver_path_0;
9042         uint32_t _ptr_data_file;
9043         TALLOC_CTX *_mem_save_data_file_0;
9044         uint32_t _ptr_config_file;
9045         TALLOC_CTX *_mem_save_config_file_0;
9046         uint32_t _ptr_help_file;
9047         TALLOC_CTX *_mem_save_help_file_0;
9048         uint32_t _ptr_dependent_files;
9049         TALLOC_CTX *_mem_save_dependent_files_0;
9050         uint32_t _ptr_monitor_name;
9051         TALLOC_CTX *_mem_save_monitor_name_0;
9052         uint32_t _ptr_default_datatype;
9053         TALLOC_CTX *_mem_save_default_datatype_0;
9054         uint32_t _ptr_previous_names;
9055         TALLOC_CTX *_mem_save_previous_names_0;
9056         uint32_t _ptr_manufacturer_name;
9057         TALLOC_CTX *_mem_save_manufacturer_name_0;
9058         uint32_t _ptr_manufacturer_url;
9059         TALLOC_CTX *_mem_save_manufacturer_url_0;
9060         uint32_t _ptr_hardware_id;
9061         TALLOC_CTX *_mem_save_hardware_id_0;
9062         uint32_t _ptr_provider;
9063         TALLOC_CTX *_mem_save_provider_0;
9064         if (ndr_flags & NDR_SCALARS) {
9065                 NDR_CHECK(ndr_pull_align(ndr, 8));
9066                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9067                 {
9068                         uint32_t _flags_save_string = ndr->flags;
9069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9070                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9071                         if (_ptr_driver_name) {
9072                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9073                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9074                         } else {
9075                                 r->driver_name = NULL;
9076                         }
9077                         ndr->flags = _flags_save_string;
9078                 }
9079                 {
9080                         uint32_t _flags_save_string = ndr->flags;
9081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9082                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9083                         if (_ptr_architecture) {
9084                                 NDR_PULL_ALLOC(ndr, r->architecture);
9085                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9086                         } else {
9087                                 r->architecture = NULL;
9088                         }
9089                         ndr->flags = _flags_save_string;
9090                 }
9091                 {
9092                         uint32_t _flags_save_string = ndr->flags;
9093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9094                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9095                         if (_ptr_driver_path) {
9096                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9097                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9098                         } else {
9099                                 r->driver_path = NULL;
9100                         }
9101                         ndr->flags = _flags_save_string;
9102                 }
9103                 {
9104                         uint32_t _flags_save_string = ndr->flags;
9105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9106                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9107                         if (_ptr_data_file) {
9108                                 NDR_PULL_ALLOC(ndr, r->data_file);
9109                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9110                         } else {
9111                                 r->data_file = NULL;
9112                         }
9113                         ndr->flags = _flags_save_string;
9114                 }
9115                 {
9116                         uint32_t _flags_save_string = ndr->flags;
9117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9119                         if (_ptr_config_file) {
9120                                 NDR_PULL_ALLOC(ndr, r->config_file);
9121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9122                         } else {
9123                                 r->config_file = NULL;
9124                         }
9125                         ndr->flags = _flags_save_string;
9126                 }
9127                 {
9128                         uint32_t _flags_save_string = ndr->flags;
9129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9131                         if (_ptr_help_file) {
9132                                 NDR_PULL_ALLOC(ndr, r->help_file);
9133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9134                         } else {
9135                                 r->help_file = NULL;
9136                         }
9137                         ndr->flags = _flags_save_string;
9138                 }
9139                 {
9140                         uint32_t _flags_save_string_array = ndr->flags;
9141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9143                         if (_ptr_dependent_files) {
9144                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9146                         } else {
9147                                 r->dependent_files = NULL;
9148                         }
9149                         ndr->flags = _flags_save_string_array;
9150                 }
9151                 {
9152                         uint32_t _flags_save_string = ndr->flags;
9153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9155                         if (_ptr_monitor_name) {
9156                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9158                         } else {
9159                                 r->monitor_name = NULL;
9160                         }
9161                         ndr->flags = _flags_save_string;
9162                 }
9163                 {
9164                         uint32_t _flags_save_string = ndr->flags;
9165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9166                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9167                         if (_ptr_default_datatype) {
9168                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9169                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9170                         } else {
9171                                 r->default_datatype = NULL;
9172                         }
9173                         ndr->flags = _flags_save_string;
9174                 }
9175                 {
9176                         uint32_t _flags_save_string_array = ndr->flags;
9177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9178                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9179                         if (_ptr_previous_names) {
9180                                 NDR_PULL_ALLOC(ndr, r->previous_names);
9181                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
9182                         } else {
9183                                 r->previous_names = NULL;
9184                         }
9185                         ndr->flags = _flags_save_string_array;
9186                 }
9187                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9188                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9189                 {
9190                         uint32_t _flags_save_string = ndr->flags;
9191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9193                         if (_ptr_manufacturer_name) {
9194                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
9196                         } else {
9197                                 r->manufacturer_name = NULL;
9198                         }
9199                         ndr->flags = _flags_save_string;
9200                 }
9201                 {
9202                         uint32_t _flags_save_string = ndr->flags;
9203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9205                         if (_ptr_manufacturer_url) {
9206                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
9208                         } else {
9209                                 r->manufacturer_url = NULL;
9210                         }
9211                         ndr->flags = _flags_save_string;
9212                 }
9213                 {
9214                         uint32_t _flags_save_string = ndr->flags;
9215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9217                         if (_ptr_hardware_id) {
9218                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
9219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
9220                         } else {
9221                                 r->hardware_id = NULL;
9222                         }
9223                         ndr->flags = _flags_save_string;
9224                 }
9225                 {
9226                         uint32_t _flags_save_string = ndr->flags;
9227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9229                         if (_ptr_provider) {
9230                                 NDR_PULL_ALLOC(ndr, r->provider);
9231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
9232                         } else {
9233                                 r->provider = NULL;
9234                         }
9235                         ndr->flags = _flags_save_string;
9236                 }
9237         }
9238         if (ndr_flags & NDR_BUFFERS) {
9239                 {
9240                         uint32_t _flags_save_string = ndr->flags;
9241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9242                         if (r->driver_name) {
9243                                 uint32_t _relative_save_offset;
9244                                 _relative_save_offset = ndr->offset;
9245                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9246                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9247                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9248                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9249                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9250                                 ndr->offset = _relative_save_offset;
9251                         }
9252                         ndr->flags = _flags_save_string;
9253                 }
9254                 {
9255                         uint32_t _flags_save_string = ndr->flags;
9256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9257                         if (r->architecture) {
9258                                 uint32_t _relative_save_offset;
9259                                 _relative_save_offset = ndr->offset;
9260                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9261                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9262                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9263                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9264                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9265                                 ndr->offset = _relative_save_offset;
9266                         }
9267                         ndr->flags = _flags_save_string;
9268                 }
9269                 {
9270                         uint32_t _flags_save_string = ndr->flags;
9271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9272                         if (r->driver_path) {
9273                                 uint32_t _relative_save_offset;
9274                                 _relative_save_offset = ndr->offset;
9275                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9276                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9277                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9278                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9279                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9280                                 ndr->offset = _relative_save_offset;
9281                         }
9282                         ndr->flags = _flags_save_string;
9283                 }
9284                 {
9285                         uint32_t _flags_save_string = ndr->flags;
9286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9287                         if (r->data_file) {
9288                                 uint32_t _relative_save_offset;
9289                                 _relative_save_offset = ndr->offset;
9290                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9291                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9292                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9293                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9294                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9295                                 ndr->offset = _relative_save_offset;
9296                         }
9297                         ndr->flags = _flags_save_string;
9298                 }
9299                 {
9300                         uint32_t _flags_save_string = ndr->flags;
9301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9302                         if (r->config_file) {
9303                                 uint32_t _relative_save_offset;
9304                                 _relative_save_offset = ndr->offset;
9305                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9306                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9307                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9308                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9309                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9310                                 ndr->offset = _relative_save_offset;
9311                         }
9312                         ndr->flags = _flags_save_string;
9313                 }
9314                 {
9315                         uint32_t _flags_save_string = ndr->flags;
9316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9317                         if (r->help_file) {
9318                                 uint32_t _relative_save_offset;
9319                                 _relative_save_offset = ndr->offset;
9320                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9321                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9322                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9323                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9324                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9325                                 ndr->offset = _relative_save_offset;
9326                         }
9327                         ndr->flags = _flags_save_string;
9328                 }
9329                 {
9330                         uint32_t _flags_save_string_array = ndr->flags;
9331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9332                         if (r->dependent_files) {
9333                                 uint32_t _relative_save_offset;
9334                                 _relative_save_offset = ndr->offset;
9335                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9336                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9337                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9338                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9339                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9340                                 ndr->offset = _relative_save_offset;
9341                         }
9342                         ndr->flags = _flags_save_string_array;
9343                 }
9344                 {
9345                         uint32_t _flags_save_string = ndr->flags;
9346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9347                         if (r->monitor_name) {
9348                                 uint32_t _relative_save_offset;
9349                                 _relative_save_offset = ndr->offset;
9350                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9351                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9352                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9353                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9354                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9355                                 ndr->offset = _relative_save_offset;
9356                         }
9357                         ndr->flags = _flags_save_string;
9358                 }
9359                 {
9360                         uint32_t _flags_save_string = ndr->flags;
9361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9362                         if (r->default_datatype) {
9363                                 uint32_t _relative_save_offset;
9364                                 _relative_save_offset = ndr->offset;
9365                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9366                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9367                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9368                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9369                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9370                                 ndr->offset = _relative_save_offset;
9371                         }
9372                         ndr->flags = _flags_save_string;
9373                 }
9374                 {
9375                         uint32_t _flags_save_string_array = ndr->flags;
9376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9377                         if (r->previous_names) {
9378                                 uint32_t _relative_save_offset;
9379                                 _relative_save_offset = ndr->offset;
9380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
9381                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9382                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9383                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
9384                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9385                                 ndr->offset = _relative_save_offset;
9386                         }
9387                         ndr->flags = _flags_save_string_array;
9388                 }
9389                 {
9390                         uint32_t _flags_save_string = ndr->flags;
9391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9392                         if (r->manufacturer_name) {
9393                                 uint32_t _relative_save_offset;
9394                                 _relative_save_offset = ndr->offset;
9395                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
9396                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9397                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9398                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
9399                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9400                                 ndr->offset = _relative_save_offset;
9401                         }
9402                         ndr->flags = _flags_save_string;
9403                 }
9404                 {
9405                         uint32_t _flags_save_string = ndr->flags;
9406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9407                         if (r->manufacturer_url) {
9408                                 uint32_t _relative_save_offset;
9409                                 _relative_save_offset = ndr->offset;
9410                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
9411                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9412                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9413                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
9414                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9415                                 ndr->offset = _relative_save_offset;
9416                         }
9417                         ndr->flags = _flags_save_string;
9418                 }
9419                 {
9420                         uint32_t _flags_save_string = ndr->flags;
9421                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9422                         if (r->hardware_id) {
9423                                 uint32_t _relative_save_offset;
9424                                 _relative_save_offset = ndr->offset;
9425                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
9426                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9427                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9428                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
9429                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9430                                 ndr->offset = _relative_save_offset;
9431                         }
9432                         ndr->flags = _flags_save_string;
9433                 }
9434                 {
9435                         uint32_t _flags_save_string = ndr->flags;
9436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9437                         if (r->provider) {
9438                                 uint32_t _relative_save_offset;
9439                                 _relative_save_offset = ndr->offset;
9440                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
9441                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9442                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9443                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
9444                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9445                                 ndr->offset = _relative_save_offset;
9446                         }
9447                         ndr->flags = _flags_save_string;
9448                 }
9449         }
9450         return NDR_ERR_SUCCESS;
9451 }
9452
9453 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
9454 {
9455         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
9456         ndr->depth++;
9457         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9458         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9459         ndr->depth++;
9460         if (r->driver_name) {
9461                 ndr_print_string(ndr, "driver_name", r->driver_name);
9462         }
9463         ndr->depth--;
9464         ndr_print_ptr(ndr, "architecture", r->architecture);
9465         ndr->depth++;
9466         if (r->architecture) {
9467                 ndr_print_string(ndr, "architecture", r->architecture);
9468         }
9469         ndr->depth--;
9470         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9471         ndr->depth++;
9472         if (r->driver_path) {
9473                 ndr_print_string(ndr, "driver_path", r->driver_path);
9474         }
9475         ndr->depth--;
9476         ndr_print_ptr(ndr, "data_file", r->data_file);
9477         ndr->depth++;
9478         if (r->data_file) {
9479                 ndr_print_string(ndr, "data_file", r->data_file);
9480         }
9481         ndr->depth--;
9482         ndr_print_ptr(ndr, "config_file", r->config_file);
9483         ndr->depth++;
9484         if (r->config_file) {
9485                 ndr_print_string(ndr, "config_file", r->config_file);
9486         }
9487         ndr->depth--;
9488         ndr_print_ptr(ndr, "help_file", r->help_file);
9489         ndr->depth++;
9490         if (r->help_file) {
9491                 ndr_print_string(ndr, "help_file", r->help_file);
9492         }
9493         ndr->depth--;
9494         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9495         ndr->depth++;
9496         if (r->dependent_files) {
9497                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9498         }
9499         ndr->depth--;
9500         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9501         ndr->depth++;
9502         if (r->monitor_name) {
9503                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9504         }
9505         ndr->depth--;
9506         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9507         ndr->depth++;
9508         if (r->default_datatype) {
9509                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9510         }
9511         ndr->depth--;
9512         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9513         ndr->depth++;
9514         if (r->previous_names) {
9515                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
9516         }
9517         ndr->depth--;
9518         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9519         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9520         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9521         ndr->depth++;
9522         if (r->manufacturer_name) {
9523                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9524         }
9525         ndr->depth--;
9526         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9527         ndr->depth++;
9528         if (r->manufacturer_url) {
9529                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9530         }
9531         ndr->depth--;
9532         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9533         ndr->depth++;
9534         if (r->hardware_id) {
9535                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9536         }
9537         ndr->depth--;
9538         ndr_print_ptr(ndr, "provider", r->provider);
9539         ndr->depth++;
9540         if (r->provider) {
9541                 ndr_print_string(ndr, "provider", r->provider);
9542         }
9543         ndr->depth--;
9544         ndr->depth--;
9545 }
9546
9547 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
9548 {
9549         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
9550 }
9551
9552 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
9553 {
9554         if (ndr_flags & NDR_SCALARS) {
9555                 NDR_CHECK(ndr_push_align(ndr, 8));
9556                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9557                 {
9558                         uint32_t _flags_save_string = ndr->flags;
9559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9560                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9561                         ndr->flags = _flags_save_string;
9562                 }
9563                 {
9564                         uint32_t _flags_save_string = ndr->flags;
9565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9566                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9567                         ndr->flags = _flags_save_string;
9568                 }
9569                 {
9570                         uint32_t _flags_save_string = ndr->flags;
9571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9572                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9573                         ndr->flags = _flags_save_string;
9574                 }
9575                 {
9576                         uint32_t _flags_save_string = ndr->flags;
9577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9578                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9579                         ndr->flags = _flags_save_string;
9580                 }
9581                 {
9582                         uint32_t _flags_save_string = ndr->flags;
9583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9584                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9585                         ndr->flags = _flags_save_string;
9586                 }
9587                 {
9588                         uint32_t _flags_save_string = ndr->flags;
9589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9590                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
9591                         ndr->flags = _flags_save_string;
9592                 }
9593                 {
9594                         uint32_t _flags_save_string = ndr->flags;
9595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9596                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
9597                         ndr->flags = _flags_save_string;
9598                 }
9599                 {
9600                         uint32_t _flags_save_string = ndr->flags;
9601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9602                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
9603                         ndr->flags = _flags_save_string;
9604                 }
9605                 {
9606                         uint32_t _flags_save_string_array = ndr->flags;
9607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9608                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
9609                         ndr->flags = _flags_save_string_array;
9610                 }
9611                 {
9612                         uint32_t _flags_save_string_array = ndr->flags;
9613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9614                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
9615                         ndr->flags = _flags_save_string_array;
9616                 }
9617                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9618                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9619                 {
9620                         uint32_t _flags_save_string = ndr->flags;
9621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9622                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
9623                         ndr->flags = _flags_save_string;
9624                 }
9625                 {
9626                         uint32_t _flags_save_string = ndr->flags;
9627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9628                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
9629                         ndr->flags = _flags_save_string;
9630                 }
9631                 {
9632                         uint32_t _flags_save_string = ndr->flags;
9633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9634                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
9635                         ndr->flags = _flags_save_string;
9636                 }
9637                 {
9638                         uint32_t _flags_save_string = ndr->flags;
9639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9640                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
9641                         ndr->flags = _flags_save_string;
9642                 }
9643                 {
9644                         uint32_t _flags_save_string = ndr->flags;
9645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9646                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
9647                         ndr->flags = _flags_save_string;
9648                 }
9649                 {
9650                         uint32_t _flags_save_string = ndr->flags;
9651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9652                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
9653                         ndr->flags = _flags_save_string;
9654                 }
9655                 {
9656                         uint32_t _flags_save_string_array = ndr->flags;
9657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9658                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
9659                         ndr->flags = _flags_save_string_array;
9660                 }
9661                 {
9662                         uint32_t _flags_save_string = ndr->flags;
9663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9664                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
9665                         ndr->flags = _flags_save_string;
9666                 }
9667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9668                 {
9669                         uint32_t _flags_save_string_array = ndr->flags;
9670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9671                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
9672                         ndr->flags = _flags_save_string_array;
9673                 }
9674                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9675                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9676         }
9677         if (ndr_flags & NDR_BUFFERS) {
9678                 {
9679                         uint32_t _flags_save_string = ndr->flags;
9680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9681                         if (r->driver_name) {
9682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9684                         }
9685                         ndr->flags = _flags_save_string;
9686                 }
9687                 {
9688                         uint32_t _flags_save_string = ndr->flags;
9689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9690                         if (r->architecture) {
9691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9693                         }
9694                         ndr->flags = _flags_save_string;
9695                 }
9696                 {
9697                         uint32_t _flags_save_string = ndr->flags;
9698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9699                         if (r->driver_path) {
9700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9702                         }
9703                         ndr->flags = _flags_save_string;
9704                 }
9705                 {
9706                         uint32_t _flags_save_string = ndr->flags;
9707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9708                         if (r->data_file) {
9709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9711                         }
9712                         ndr->flags = _flags_save_string;
9713                 }
9714                 {
9715                         uint32_t _flags_save_string = ndr->flags;
9716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9717                         if (r->config_file) {
9718                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9719                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9720                         }
9721                         ndr->flags = _flags_save_string;
9722                 }
9723                 {
9724                         uint32_t _flags_save_string = ndr->flags;
9725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9726                         if (r->help_file) {
9727                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
9728                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
9729                         }
9730                         ndr->flags = _flags_save_string;
9731                 }
9732                 {
9733                         uint32_t _flags_save_string = ndr->flags;
9734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9735                         if (r->monitor_name) {
9736                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
9737                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
9738                         }
9739                         ndr->flags = _flags_save_string;
9740                 }
9741                 {
9742                         uint32_t _flags_save_string = ndr->flags;
9743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9744                         if (r->default_datatype) {
9745                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9746                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9747                         }
9748                         ndr->flags = _flags_save_string;
9749                 }
9750                 {
9751                         uint32_t _flags_save_string_array = ndr->flags;
9752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9753                         if (r->dependent_files) {
9754                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
9755                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
9756                         }
9757                         ndr->flags = _flags_save_string_array;
9758                 }
9759                 {
9760                         uint32_t _flags_save_string_array = ndr->flags;
9761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9762                         if (r->previous_names) {
9763                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9764                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9765                         }
9766                         ndr->flags = _flags_save_string_array;
9767                 }
9768                 {
9769                         uint32_t _flags_save_string = ndr->flags;
9770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9771                         if (r->manufacturer_name) {
9772                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9773                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9774                         }
9775                         ndr->flags = _flags_save_string;
9776                 }
9777                 {
9778                         uint32_t _flags_save_string = ndr->flags;
9779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9780                         if (r->manufacturer_url) {
9781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9783                         }
9784                         ndr->flags = _flags_save_string;
9785                 }
9786                 {
9787                         uint32_t _flags_save_string = ndr->flags;
9788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9789                         if (r->hardware_id) {
9790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9792                         }
9793                         ndr->flags = _flags_save_string;
9794                 }
9795                 {
9796                         uint32_t _flags_save_string = ndr->flags;
9797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9798                         if (r->provider) {
9799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9801                         }
9802                         ndr->flags = _flags_save_string;
9803                 }
9804                 {
9805                         uint32_t _flags_save_string = ndr->flags;
9806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9807                         if (r->print_processor) {
9808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
9809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
9810                         }
9811                         ndr->flags = _flags_save_string;
9812                 }
9813                 {
9814                         uint32_t _flags_save_string = ndr->flags;
9815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9816                         if (r->vendor_setup) {
9817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
9818                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
9819                         }
9820                         ndr->flags = _flags_save_string;
9821                 }
9822                 {
9823                         uint32_t _flags_save_string_array = ndr->flags;
9824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9825                         if (r->color_profiles) {
9826                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
9827                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
9828                         }
9829                         ndr->flags = _flags_save_string_array;
9830                 }
9831                 {
9832                         uint32_t _flags_save_string = ndr->flags;
9833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9834                         if (r->inf_path) {
9835                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
9836                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
9837                         }
9838                         ndr->flags = _flags_save_string;
9839                 }
9840                 {
9841                         uint32_t _flags_save_string_array = ndr->flags;
9842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9843                         if (r->core_driver_dependencies) {
9844                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
9845                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
9846                         }
9847                         ndr->flags = _flags_save_string_array;
9848                 }
9849         }
9850         return NDR_ERR_SUCCESS;
9851 }
9852
9853 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
9854 {
9855         uint32_t _ptr_driver_name;
9856         TALLOC_CTX *_mem_save_driver_name_0;
9857         uint32_t _ptr_architecture;
9858         TALLOC_CTX *_mem_save_architecture_0;
9859         uint32_t _ptr_driver_path;
9860         TALLOC_CTX *_mem_save_driver_path_0;
9861         uint32_t _ptr_data_file;
9862         TALLOC_CTX *_mem_save_data_file_0;
9863         uint32_t _ptr_config_file;
9864         TALLOC_CTX *_mem_save_config_file_0;
9865         uint32_t _ptr_help_file;
9866         TALLOC_CTX *_mem_save_help_file_0;
9867         uint32_t _ptr_monitor_name;
9868         TALLOC_CTX *_mem_save_monitor_name_0;
9869         uint32_t _ptr_default_datatype;
9870         TALLOC_CTX *_mem_save_default_datatype_0;
9871         uint32_t _ptr_dependent_files;
9872         TALLOC_CTX *_mem_save_dependent_files_0;
9873         uint32_t _ptr_previous_names;
9874         TALLOC_CTX *_mem_save_previous_names_0;
9875         uint32_t _ptr_manufacturer_name;
9876         TALLOC_CTX *_mem_save_manufacturer_name_0;
9877         uint32_t _ptr_manufacturer_url;
9878         TALLOC_CTX *_mem_save_manufacturer_url_0;
9879         uint32_t _ptr_hardware_id;
9880         TALLOC_CTX *_mem_save_hardware_id_0;
9881         uint32_t _ptr_provider;
9882         TALLOC_CTX *_mem_save_provider_0;
9883         uint32_t _ptr_print_processor;
9884         TALLOC_CTX *_mem_save_print_processor_0;
9885         uint32_t _ptr_vendor_setup;
9886         TALLOC_CTX *_mem_save_vendor_setup_0;
9887         uint32_t _ptr_color_profiles;
9888         TALLOC_CTX *_mem_save_color_profiles_0;
9889         uint32_t _ptr_inf_path;
9890         TALLOC_CTX *_mem_save_inf_path_0;
9891         uint32_t _ptr_core_driver_dependencies;
9892         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9893         if (ndr_flags & NDR_SCALARS) {
9894                 NDR_CHECK(ndr_pull_align(ndr, 8));
9895                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9896                 {
9897                         uint32_t _flags_save_string = ndr->flags;
9898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9899                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9900                         if (_ptr_driver_name) {
9901                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9902                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9903                         } else {
9904                                 r->driver_name = NULL;
9905                         }
9906                         ndr->flags = _flags_save_string;
9907                 }
9908                 {
9909                         uint32_t _flags_save_string = ndr->flags;
9910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9911                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9912                         if (_ptr_architecture) {
9913                                 NDR_PULL_ALLOC(ndr, r->architecture);
9914                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9915                         } else {
9916                                 r->architecture = NULL;
9917                         }
9918                         ndr->flags = _flags_save_string;
9919                 }
9920                 {
9921                         uint32_t _flags_save_string = ndr->flags;
9922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9923                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9924                         if (_ptr_driver_path) {
9925                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9926                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9927                         } else {
9928                                 r->driver_path = NULL;
9929                         }
9930                         ndr->flags = _flags_save_string;
9931                 }
9932                 {
9933                         uint32_t _flags_save_string = ndr->flags;
9934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9935                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9936                         if (_ptr_data_file) {
9937                                 NDR_PULL_ALLOC(ndr, r->data_file);
9938                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9939                         } else {
9940                                 r->data_file = NULL;
9941                         }
9942                         ndr->flags = _flags_save_string;
9943                 }
9944                 {
9945                         uint32_t _flags_save_string = ndr->flags;
9946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9947                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9948                         if (_ptr_config_file) {
9949                                 NDR_PULL_ALLOC(ndr, r->config_file);
9950                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9951                         } else {
9952                                 r->config_file = NULL;
9953                         }
9954                         ndr->flags = _flags_save_string;
9955                 }
9956                 {
9957                         uint32_t _flags_save_string = ndr->flags;
9958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9959                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9960                         if (_ptr_help_file) {
9961                                 NDR_PULL_ALLOC(ndr, r->help_file);
9962                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9963                         } else {
9964                                 r->help_file = NULL;
9965                         }
9966                         ndr->flags = _flags_save_string;
9967                 }
9968                 {
9969                         uint32_t _flags_save_string = ndr->flags;
9970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9971                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9972                         if (_ptr_monitor_name) {
9973                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9974                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9975                         } else {
9976                                 r->monitor_name = NULL;
9977                         }
9978                         ndr->flags = _flags_save_string;
9979                 }
9980                 {
9981                         uint32_t _flags_save_string = ndr->flags;
9982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9983                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9984                         if (_ptr_default_datatype) {
9985                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9986                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9987                         } else {
9988                                 r->default_datatype = NULL;
9989                         }
9990                         ndr->flags = _flags_save_string;
9991                 }
9992                 {
9993                         uint32_t _flags_save_string_array = ndr->flags;
9994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9995                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9996                         if (_ptr_dependent_files) {
9997                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9998                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9999                         } else {
10000                                 r->dependent_files = NULL;
10001                         }
10002                         ndr->flags = _flags_save_string_array;
10003                 }
10004                 {
10005                         uint32_t _flags_save_string_array = ndr->flags;
10006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10007                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10008                         if (_ptr_previous_names) {
10009                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10010                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10011                         } else {
10012                                 r->previous_names = NULL;
10013                         }
10014                         ndr->flags = _flags_save_string_array;
10015                 }
10016                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
10017                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10018                 {
10019                         uint32_t _flags_save_string = ndr->flags;
10020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10021                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10022                         if (_ptr_manufacturer_name) {
10023                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10024                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
10025                         } else {
10026                                 r->manufacturer_name = NULL;
10027                         }
10028                         ndr->flags = _flags_save_string;
10029                 }
10030                 {
10031                         uint32_t _flags_save_string = ndr->flags;
10032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10033                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10034                         if (_ptr_manufacturer_url) {
10035                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10036                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
10037                         } else {
10038                                 r->manufacturer_url = NULL;
10039                         }
10040                         ndr->flags = _flags_save_string;
10041                 }
10042                 {
10043                         uint32_t _flags_save_string = ndr->flags;
10044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10045                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10046                         if (_ptr_hardware_id) {
10047                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
10048                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
10049                         } else {
10050                                 r->hardware_id = NULL;
10051                         }
10052                         ndr->flags = _flags_save_string;
10053                 }
10054                 {
10055                         uint32_t _flags_save_string = ndr->flags;
10056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10057                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10058                         if (_ptr_provider) {
10059                                 NDR_PULL_ALLOC(ndr, r->provider);
10060                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
10061                         } else {
10062                                 r->provider = NULL;
10063                         }
10064                         ndr->flags = _flags_save_string;
10065                 }
10066                 {
10067                         uint32_t _flags_save_string = ndr->flags;
10068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10069                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10070                         if (_ptr_print_processor) {
10071                                 NDR_PULL_ALLOC(ndr, r->print_processor);
10072                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
10073                         } else {
10074                                 r->print_processor = NULL;
10075                         }
10076                         ndr->flags = _flags_save_string;
10077                 }
10078                 {
10079                         uint32_t _flags_save_string = ndr->flags;
10080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10081                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10082                         if (_ptr_vendor_setup) {
10083                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
10084                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
10085                         } else {
10086                                 r->vendor_setup = NULL;
10087                         }
10088                         ndr->flags = _flags_save_string;
10089                 }
10090                 {
10091                         uint32_t _flags_save_string_array = ndr->flags;
10092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10093                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10094                         if (_ptr_color_profiles) {
10095                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
10096                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
10097                         } else {
10098                                 r->color_profiles = NULL;
10099                         }
10100                         ndr->flags = _flags_save_string_array;
10101                 }
10102                 {
10103                         uint32_t _flags_save_string = ndr->flags;
10104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10105                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10106                         if (_ptr_inf_path) {
10107                                 NDR_PULL_ALLOC(ndr, r->inf_path);
10108                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
10109                         } else {
10110                                 r->inf_path = NULL;
10111                         }
10112                         ndr->flags = _flags_save_string;
10113                 }
10114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10115                 {
10116                         uint32_t _flags_save_string_array = ndr->flags;
10117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10119                         if (_ptr_core_driver_dependencies) {
10120                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
10122                         } else {
10123                                 r->core_driver_dependencies = NULL;
10124                         }
10125                         ndr->flags = _flags_save_string_array;
10126                 }
10127                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10128                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10129         }
10130         if (ndr_flags & NDR_BUFFERS) {
10131                 {
10132                         uint32_t _flags_save_string = ndr->flags;
10133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10134                         if (r->driver_name) {
10135                                 uint32_t _relative_save_offset;
10136                                 _relative_save_offset = ndr->offset;
10137                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10138                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10139                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10140                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10141                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10142                                 ndr->offset = _relative_save_offset;
10143                         }
10144                         ndr->flags = _flags_save_string;
10145                 }
10146                 {
10147                         uint32_t _flags_save_string = ndr->flags;
10148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10149                         if (r->architecture) {
10150                                 uint32_t _relative_save_offset;
10151                                 _relative_save_offset = ndr->offset;
10152                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10153                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10154                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10155                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10156                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10157                                 ndr->offset = _relative_save_offset;
10158                         }
10159                         ndr->flags = _flags_save_string;
10160                 }
10161                 {
10162                         uint32_t _flags_save_string = ndr->flags;
10163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10164                         if (r->driver_path) {
10165                                 uint32_t _relative_save_offset;
10166                                 _relative_save_offset = ndr->offset;
10167                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10168                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10169                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10170                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10171                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10172                                 ndr->offset = _relative_save_offset;
10173                         }
10174                         ndr->flags = _flags_save_string;
10175                 }
10176                 {
10177                         uint32_t _flags_save_string = ndr->flags;
10178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10179                         if (r->data_file) {
10180                                 uint32_t _relative_save_offset;
10181                                 _relative_save_offset = ndr->offset;
10182                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10183                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10184                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10185                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10186                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10187                                 ndr->offset = _relative_save_offset;
10188                         }
10189                         ndr->flags = _flags_save_string;
10190                 }
10191                 {
10192                         uint32_t _flags_save_string = ndr->flags;
10193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10194                         if (r->config_file) {
10195                                 uint32_t _relative_save_offset;
10196                                 _relative_save_offset = ndr->offset;
10197                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10198                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10199                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10200                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10201                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10202                                 ndr->offset = _relative_save_offset;
10203                         }
10204                         ndr->flags = _flags_save_string;
10205                 }
10206                 {
10207                         uint32_t _flags_save_string = ndr->flags;
10208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10209                         if (r->help_file) {
10210                                 uint32_t _relative_save_offset;
10211                                 _relative_save_offset = ndr->offset;
10212                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10213                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10214                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10215                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10216                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10217                                 ndr->offset = _relative_save_offset;
10218                         }
10219                         ndr->flags = _flags_save_string;
10220                 }
10221                 {
10222                         uint32_t _flags_save_string = ndr->flags;
10223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10224                         if (r->monitor_name) {
10225                                 uint32_t _relative_save_offset;
10226                                 _relative_save_offset = ndr->offset;
10227                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10228                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10229                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10230                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10231                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10232                                 ndr->offset = _relative_save_offset;
10233                         }
10234                         ndr->flags = _flags_save_string;
10235                 }
10236                 {
10237                         uint32_t _flags_save_string = ndr->flags;
10238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10239                         if (r->default_datatype) {
10240                                 uint32_t _relative_save_offset;
10241                                 _relative_save_offset = ndr->offset;
10242                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10243                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10244                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10245                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10246                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10247                                 ndr->offset = _relative_save_offset;
10248                         }
10249                         ndr->flags = _flags_save_string;
10250                 }
10251                 {
10252                         uint32_t _flags_save_string_array = ndr->flags;
10253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10254                         if (r->dependent_files) {
10255                                 uint32_t _relative_save_offset;
10256                                 _relative_save_offset = ndr->offset;
10257                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10258                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10259                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10260                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10261                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10262                                 ndr->offset = _relative_save_offset;
10263                         }
10264                         ndr->flags = _flags_save_string_array;
10265                 }
10266                 {
10267                         uint32_t _flags_save_string_array = ndr->flags;
10268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10269                         if (r->previous_names) {
10270                                 uint32_t _relative_save_offset;
10271                                 _relative_save_offset = ndr->offset;
10272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
10273                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10274                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10275                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
10276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10277                                 ndr->offset = _relative_save_offset;
10278                         }
10279                         ndr->flags = _flags_save_string_array;
10280                 }
10281                 {
10282                         uint32_t _flags_save_string = ndr->flags;
10283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10284                         if (r->manufacturer_name) {
10285                                 uint32_t _relative_save_offset;
10286                                 _relative_save_offset = ndr->offset;
10287                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
10288                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10289                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10290                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
10291                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10292                                 ndr->offset = _relative_save_offset;
10293                         }
10294                         ndr->flags = _flags_save_string;
10295                 }
10296                 {
10297                         uint32_t _flags_save_string = ndr->flags;
10298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10299                         if (r->manufacturer_url) {
10300                                 uint32_t _relative_save_offset;
10301                                 _relative_save_offset = ndr->offset;
10302                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
10303                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10304                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10305                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
10306                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10307                                 ndr->offset = _relative_save_offset;
10308                         }
10309                         ndr->flags = _flags_save_string;
10310                 }
10311                 {
10312                         uint32_t _flags_save_string = ndr->flags;
10313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10314                         if (r->hardware_id) {
10315                                 uint32_t _relative_save_offset;
10316                                 _relative_save_offset = ndr->offset;
10317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
10318                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10319                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
10321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10322                                 ndr->offset = _relative_save_offset;
10323                         }
10324                         ndr->flags = _flags_save_string;
10325                 }
10326                 {
10327                         uint32_t _flags_save_string = ndr->flags;
10328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10329                         if (r->provider) {
10330                                 uint32_t _relative_save_offset;
10331                                 _relative_save_offset = ndr->offset;
10332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
10333                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10334                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
10336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10337                                 ndr->offset = _relative_save_offset;
10338                         }
10339                         ndr->flags = _flags_save_string;
10340                 }
10341                 {
10342                         uint32_t _flags_save_string = ndr->flags;
10343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10344                         if (r->print_processor) {
10345                                 uint32_t _relative_save_offset;
10346                                 _relative_save_offset = ndr->offset;
10347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
10348                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10349                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
10351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10352                                 ndr->offset = _relative_save_offset;
10353                         }
10354                         ndr->flags = _flags_save_string;
10355                 }
10356                 {
10357                         uint32_t _flags_save_string = ndr->flags;
10358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10359                         if (r->vendor_setup) {
10360                                 uint32_t _relative_save_offset;
10361                                 _relative_save_offset = ndr->offset;
10362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
10363                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10364                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
10366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10367                                 ndr->offset = _relative_save_offset;
10368                         }
10369                         ndr->flags = _flags_save_string;
10370                 }
10371                 {
10372                         uint32_t _flags_save_string_array = ndr->flags;
10373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10374                         if (r->color_profiles) {
10375                                 uint32_t _relative_save_offset;
10376                                 _relative_save_offset = ndr->offset;
10377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
10378                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10379                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10380                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
10381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10382                                 ndr->offset = _relative_save_offset;
10383                         }
10384                         ndr->flags = _flags_save_string_array;
10385                 }
10386                 {
10387                         uint32_t _flags_save_string = ndr->flags;
10388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10389                         if (r->inf_path) {
10390                                 uint32_t _relative_save_offset;
10391                                 _relative_save_offset = ndr->offset;
10392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
10393                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10394                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
10396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10397                                 ndr->offset = _relative_save_offset;
10398                         }
10399                         ndr->flags = _flags_save_string;
10400                 }
10401                 {
10402                         uint32_t _flags_save_string_array = ndr->flags;
10403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10404                         if (r->core_driver_dependencies) {
10405                                 uint32_t _relative_save_offset;
10406                                 _relative_save_offset = ndr->offset;
10407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
10408                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10409                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10410                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
10411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10412                                 ndr->offset = _relative_save_offset;
10413                         }
10414                         ndr->flags = _flags_save_string_array;
10415                 }
10416         }
10417         return NDR_ERR_SUCCESS;
10418 }
10419
10420 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
10421 {
10422         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
10423         ndr->depth++;
10424         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10425         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10426         ndr->depth++;
10427         if (r->driver_name) {
10428                 ndr_print_string(ndr, "driver_name", r->driver_name);
10429         }
10430         ndr->depth--;
10431         ndr_print_ptr(ndr, "architecture", r->architecture);
10432         ndr->depth++;
10433         if (r->architecture) {
10434                 ndr_print_string(ndr, "architecture", r->architecture);
10435         }
10436         ndr->depth--;
10437         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10438         ndr->depth++;
10439         if (r->driver_path) {
10440                 ndr_print_string(ndr, "driver_path", r->driver_path);
10441         }
10442         ndr->depth--;
10443         ndr_print_ptr(ndr, "data_file", r->data_file);
10444         ndr->depth++;
10445         if (r->data_file) {
10446                 ndr_print_string(ndr, "data_file", r->data_file);
10447         }
10448         ndr->depth--;
10449         ndr_print_ptr(ndr, "config_file", r->config_file);
10450         ndr->depth++;
10451         if (r->config_file) {
10452                 ndr_print_string(ndr, "config_file", r->config_file);
10453         }
10454         ndr->depth--;
10455         ndr_print_ptr(ndr, "help_file", r->help_file);
10456         ndr->depth++;
10457         if (r->help_file) {
10458                 ndr_print_string(ndr, "help_file", r->help_file);
10459         }
10460         ndr->depth--;
10461         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10462         ndr->depth++;
10463         if (r->monitor_name) {
10464                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10465         }
10466         ndr->depth--;
10467         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10468         ndr->depth++;
10469         if (r->default_datatype) {
10470                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10471         }
10472         ndr->depth--;
10473         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10474         ndr->depth++;
10475         if (r->dependent_files) {
10476                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10477         }
10478         ndr->depth--;
10479         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10480         ndr->depth++;
10481         if (r->previous_names) {
10482                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10483         }
10484         ndr->depth--;
10485         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10486         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10487         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10488         ndr->depth++;
10489         if (r->manufacturer_name) {
10490                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10491         }
10492         ndr->depth--;
10493         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10494         ndr->depth++;
10495         if (r->manufacturer_url) {
10496                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10497         }
10498         ndr->depth--;
10499         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10500         ndr->depth++;
10501         if (r->hardware_id) {
10502                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10503         }
10504         ndr->depth--;
10505         ndr_print_ptr(ndr, "provider", r->provider);
10506         ndr->depth++;
10507         if (r->provider) {
10508                 ndr_print_string(ndr, "provider", r->provider);
10509         }
10510         ndr->depth--;
10511         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10512         ndr->depth++;
10513         if (r->print_processor) {
10514                 ndr_print_string(ndr, "print_processor", r->print_processor);
10515         }
10516         ndr->depth--;
10517         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10518         ndr->depth++;
10519         if (r->vendor_setup) {
10520                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10521         }
10522         ndr->depth--;
10523         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10524         ndr->depth++;
10525         if (r->color_profiles) {
10526                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
10527         }
10528         ndr->depth--;
10529         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10530         ndr->depth++;
10531         if (r->inf_path) {
10532                 ndr_print_string(ndr, "inf_path", r->inf_path);
10533         }
10534         ndr->depth--;
10535         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10536         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10537         ndr->depth++;
10538         if (r->core_driver_dependencies) {
10539                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10540         }
10541         ndr->depth--;
10542         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10543         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10544         ndr->depth--;
10545 }
10546
10547 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
10548 {
10549         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
10550 }
10551
10552 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
10553 {
10554         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
10555         return NDR_ERR_SUCCESS;
10556 }
10557
10558 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
10559 {
10560         uint32_t v;
10561         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
10562         *r = v;
10563         return NDR_ERR_SUCCESS;
10564 }
10565
10566 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
10567 {
10568         const char *val = NULL;
10569
10570         switch (r) {
10571                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
10572                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
10573                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
10574                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
10575                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
10576         }
10577         ndr_print_enum(ndr, name, "ENUM", val, r);
10578 }
10579
10580 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
10581 {
10582         if (ndr_flags & NDR_SCALARS) {
10583                 NDR_CHECK(ndr_push_align(ndr, 4));
10584                 {
10585                         uint32_t _flags_save_string = ndr->flags;
10586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
10588                         ndr->flags = _flags_save_string;
10589                 }
10590                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
10591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
10592         }
10593         if (ndr_flags & NDR_BUFFERS) {
10594                 {
10595                         uint32_t _flags_save_string = ndr->flags;
10596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10597                         if (r->file_name) {
10598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
10599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
10600                         }
10601                         ndr->flags = _flags_save_string;
10602                 }
10603         }
10604         return NDR_ERR_SUCCESS;
10605 }
10606
10607 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
10608 {
10609         uint32_t _ptr_file_name;
10610         TALLOC_CTX *_mem_save_file_name_0;
10611         if (ndr_flags & NDR_SCALARS) {
10612                 NDR_CHECK(ndr_pull_align(ndr, 4));
10613                 {
10614                         uint32_t _flags_save_string = ndr->flags;
10615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10616                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
10617                         if (_ptr_file_name) {
10618                                 NDR_PULL_ALLOC(ndr, r->file_name);
10619                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
10620                         } else {
10621                                 r->file_name = NULL;
10622                         }
10623                         ndr->flags = _flags_save_string;
10624                 }
10625                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
10626                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
10627         }
10628         if (ndr_flags & NDR_BUFFERS) {
10629                 {
10630                         uint32_t _flags_save_string = ndr->flags;
10631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10632                         if (r->file_name) {
10633                                 uint32_t _relative_save_offset;
10634                                 _relative_save_offset = ndr->offset;
10635                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
10636                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10637                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
10638                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
10639                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
10640                                 ndr->offset = _relative_save_offset;
10641                         }
10642                         ndr->flags = _flags_save_string;
10643                 }
10644         }
10645         return NDR_ERR_SUCCESS;
10646 }
10647
10648 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
10649 {
10650         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
10651         ndr->depth++;
10652         ndr_print_ptr(ndr, "file_name", r->file_name);
10653         ndr->depth++;
10654         if (r->file_name) {
10655                 ndr_print_string(ndr, "file_name", r->file_name);
10656         }
10657         ndr->depth--;
10658         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
10659         ndr_print_uint32(ndr, "file_version", r->file_version);
10660         ndr->depth--;
10661 }
10662
10663 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
10664 {
10665         uint32_t cntr_file_info_1;
10666         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
10667         ndr->depth++;
10668         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10669         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10670         ndr->depth++;
10671         if (r->driver_name) {
10672                 ndr_print_string(ndr, "driver_name", r->driver_name);
10673         }
10674         ndr->depth--;
10675         ndr_print_ptr(ndr, "architecture", r->architecture);
10676         ndr->depth++;
10677         if (r->architecture) {
10678                 ndr_print_string(ndr, "architecture", r->architecture);
10679         }
10680         ndr->depth--;
10681         ndr_print_ptr(ndr, "file_info", r->file_info);
10682         ndr->depth++;
10683         if (r->file_info) {
10684                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
10685                 ndr->depth++;
10686                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
10687                         char *idx_1=NULL;
10688                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
10689                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
10690                                 free(idx_1);
10691                         }
10692                 }
10693                 ndr->depth--;
10694         }
10695         ndr->depth--;
10696         ndr_print_uint32(ndr, "file_count", r->file_count);
10697         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10698         ndr->depth++;
10699         if (r->monitor_name) {
10700                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10701         }
10702         ndr->depth--;
10703         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10704         ndr->depth++;
10705         if (r->default_datatype) {
10706                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10707         }
10708         ndr->depth--;
10709         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10710         ndr->depth++;
10711         if (r->previous_names) {
10712                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10713         }
10714         ndr->depth--;
10715         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10716         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10717         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10718         ndr->depth++;
10719         if (r->manufacturer_name) {
10720                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10721         }
10722         ndr->depth--;
10723         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10724         ndr->depth++;
10725         if (r->manufacturer_url) {
10726                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10727         }
10728         ndr->depth--;
10729         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10730         ndr->depth++;
10731         if (r->hardware_id) {
10732                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10733         }
10734         ndr->depth--;
10735         ndr_print_ptr(ndr, "provider", r->provider);
10736         ndr->depth++;
10737         if (r->provider) {
10738                 ndr_print_string(ndr, "provider", r->provider);
10739         }
10740         ndr->depth--;
10741         ndr->depth--;
10742 }
10743
10744 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
10745 {
10746         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
10747 }
10748
10749 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
10750 {
10751         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10752         if (ndr_flags & NDR_SCALARS) {
10753                 int level = ndr_push_get_switch_value(ndr, r);
10754                 switch (level) {
10755                         case 1: {
10756                                 NDR_CHECK(ndr_push_align(ndr, 4));
10757                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10758                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10759                         break; }
10760
10761                         case 2: {
10762                                 NDR_CHECK(ndr_push_align(ndr, 4));
10763                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10764                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10765                         break; }
10766
10767                         case 3: {
10768                                 NDR_CHECK(ndr_push_align(ndr, 4));
10769                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10770                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10771                         break; }
10772
10773                         case 4: {
10774                                 NDR_CHECK(ndr_push_align(ndr, 4));
10775                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10776                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10777                         break; }
10778
10779                         case 5: {
10780                                 NDR_CHECK(ndr_push_align(ndr, 4));
10781                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10782                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10783                         break; }
10784
10785                         case 6: {
10786                                 NDR_CHECK(ndr_push_align(ndr, 8));
10787                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10788                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10789                         break; }
10790
10791                         case 8: {
10792                                 NDR_CHECK(ndr_push_align(ndr, 8));
10793                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10794                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10795                         break; }
10796
10797                         case 101: {
10798                                 NDR_CHECK(ndr_push_align(ndr, 8));
10799                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10800                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
10801                         break; }
10802
10803                         default: {
10804                         break; }
10805
10806                 }
10807         }
10808         if (ndr_flags & NDR_BUFFERS) {
10809                 int level = ndr_push_get_switch_value(ndr, r);
10810                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10811                 switch (level) {
10812                         case 1:
10813                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10814                         break;
10815
10816                         case 2:
10817                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10818                         break;
10819
10820                         case 3:
10821                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10822                         break;
10823
10824                         case 4:
10825                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10826                         break;
10827
10828                         case 5:
10829                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10830                         break;
10831
10832                         case 6:
10833                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10834                         break;
10835
10836                         case 8:
10837                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10838                         break;
10839
10840                         case 101:
10841                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
10842                         break;
10843
10844                         default:
10845                         break;
10846
10847                 }
10848         }
10849         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10850         return NDR_ERR_SUCCESS;
10851 }
10852
10853 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
10854 {
10855         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10856         int level;
10857         level = ndr_pull_get_switch_value(ndr, r);
10858         if (ndr_flags & NDR_SCALARS) {
10859                 switch (level) {
10860                         case 1: {
10861                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10862                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10863                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10864                         break; }
10865
10866                         case 2: {
10867                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10868                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10869                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10870                         break; }
10871
10872                         case 3: {
10873                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10874                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10875                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10876                         break; }
10877
10878                         case 4: {
10879                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10880                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10881                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10882                         break; }
10883
10884                         case 5: {
10885                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10886                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10887                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10888                         break; }
10889
10890                         case 6: {
10891                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10892                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10893                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10894                         break; }
10895
10896                         case 8: {
10897                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10898                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10899                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10900                         break; }
10901
10902                         case 101: {
10903                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10904                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10905                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
10906                         break; }
10907
10908                         default: {
10909                         break; }
10910
10911                 }
10912         }
10913         if (ndr_flags & NDR_BUFFERS) {
10914                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10915                 switch (level) {
10916                         case 1:
10917                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10918                         break;
10919
10920                         case 2:
10921                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10922                         break;
10923
10924                         case 3:
10925                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10926                         break;
10927
10928                         case 4:
10929                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10930                         break;
10931
10932                         case 5:
10933                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10934                         break;
10935
10936                         case 6:
10937                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10938                         break;
10939
10940                         case 8:
10941                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10942                         break;
10943
10944                         case 101:
10945                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
10946                         break;
10947
10948                         default:
10949                         break;
10950
10951                 }
10952         }
10953         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10954         return NDR_ERR_SUCCESS;
10955 }
10956
10957 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
10958 {
10959         int level;
10960         level = ndr_print_get_switch_value(ndr, r);
10961         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
10962         switch (level) {
10963                 case 1:
10964                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
10965                 break;
10966
10967                 case 2:
10968                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
10969                 break;
10970
10971                 case 3:
10972                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
10973                 break;
10974
10975                 case 4:
10976                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
10977                 break;
10978
10979                 case 5:
10980                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
10981                 break;
10982
10983                 case 6:
10984                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
10985                 break;
10986
10987                 case 8:
10988                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
10989                 break;
10990
10991                 case 101:
10992                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
10993                 break;
10994
10995                 default:
10996                 break;
10997
10998         }
10999 }
11000
11001 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
11002 {
11003         if (ndr_flags & NDR_SCALARS) {
11004                 NDR_CHECK(ndr_push_align(ndr, 4));
11005                 {
11006                         uint32_t _flags_save_string = ndr->flags;
11007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11008                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
11009                         ndr->flags = _flags_save_string;
11010                 }
11011         }
11012         if (ndr_flags & NDR_BUFFERS) {
11013         }
11014         return NDR_ERR_SUCCESS;
11015 }
11016
11017 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
11018 {
11019         if (ndr_flags & NDR_SCALARS) {
11020                 NDR_CHECK(ndr_pull_align(ndr, 4));
11021                 {
11022                         uint32_t _flags_save_string = ndr->flags;
11023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11024                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
11025                         ndr->flags = _flags_save_string;
11026                 }
11027         }
11028         if (ndr_flags & NDR_BUFFERS) {
11029         }
11030         return NDR_ERR_SUCCESS;
11031 }
11032
11033 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
11034 {
11035         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
11036         ndr->depth++;
11037         ndr_print_string(ndr, "directory_name", r->directory_name);
11038         ndr->depth--;
11039 }
11040
11041 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
11042 {
11043         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
11044 }
11045
11046 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
11047 {
11048         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11049         if (ndr_flags & NDR_SCALARS) {
11050                 int level = ndr_push_get_switch_value(ndr, r);
11051                 switch (level) {
11052                         case 1: {
11053                                 NDR_CHECK(ndr_push_align(ndr, 4));
11054                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11055                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11056                         break; }
11057
11058                         default: {
11059                                 NDR_CHECK(ndr_push_align(ndr, 4));
11060                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11061                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11062                         break; }
11063
11064                 }
11065         }
11066         if (ndr_flags & NDR_BUFFERS) {
11067                 int level = ndr_push_get_switch_value(ndr, r);
11068                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11069                 switch (level) {
11070                         case 1:
11071                         break;
11072
11073                         default:
11074                         break;
11075
11076                 }
11077         }
11078         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11079         return NDR_ERR_SUCCESS;
11080 }
11081
11082 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
11083 {
11084         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11085         int level;
11086         level = ndr_pull_get_switch_value(ndr, r);
11087         if (ndr_flags & NDR_SCALARS) {
11088                 switch (level) {
11089                         case 1: {
11090                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11091                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11092                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11093                         break; }
11094
11095                         default: {
11096                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11097                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11098                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11099                         break; }
11100
11101                 }
11102         }
11103         if (ndr_flags & NDR_BUFFERS) {
11104                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11105                 switch (level) {
11106                         case 1:
11107                         break;
11108
11109                         default:
11110                         break;
11111
11112                 }
11113         }
11114         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11115         return NDR_ERR_SUCCESS;
11116 }
11117
11118 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
11119 {
11120         int level;
11121         level = ndr_print_get_switch_value(ndr, r);
11122         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
11123         switch (level) {
11124                 case 1:
11125                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
11126                 break;
11127
11128                 default:
11129                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
11130                 break;
11131
11132         }
11133 }
11134
11135 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11136 {
11137         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
11138 }
11139
11140 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
11141 {
11142         if (ndr_flags & NDR_SCALARS) {
11143                 NDR_CHECK(ndr_push_align(ndr, 4));
11144                 {
11145                         uint32_t _flags_save_string = ndr->flags;
11146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11147                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
11148                         ndr->flags = _flags_save_string;
11149                 }
11150         }
11151         if (ndr_flags & NDR_BUFFERS) {
11152                 {
11153                         uint32_t _flags_save_string = ndr->flags;
11154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11155                         if (r->print_processor_name) {
11156                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
11157                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
11158                         }
11159                         ndr->flags = _flags_save_string;
11160                 }
11161         }
11162         return NDR_ERR_SUCCESS;
11163 }
11164
11165 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
11166 {
11167         uint32_t _ptr_print_processor_name;
11168         TALLOC_CTX *_mem_save_print_processor_name_0;
11169         if (ndr_flags & NDR_SCALARS) {
11170                 NDR_CHECK(ndr_pull_align(ndr, 4));
11171                 {
11172                         uint32_t _flags_save_string = ndr->flags;
11173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11174                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
11175                         if (_ptr_print_processor_name) {
11176                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
11177                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
11178                         } else {
11179                                 r->print_processor_name = NULL;
11180                         }
11181                         ndr->flags = _flags_save_string;
11182                 }
11183         }
11184         if (ndr_flags & NDR_BUFFERS) {
11185                 {
11186                         uint32_t _flags_save_string = ndr->flags;
11187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11188                         if (r->print_processor_name) {
11189                                 uint32_t _relative_save_offset;
11190                                 _relative_save_offset = ndr->offset;
11191                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
11192                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11193                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
11194                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
11195                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
11196                                 ndr->offset = _relative_save_offset;
11197                         }
11198                         ndr->flags = _flags_save_string;
11199                 }
11200         }
11201         return NDR_ERR_SUCCESS;
11202 }
11203
11204 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
11205 {
11206         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
11207         ndr->depth++;
11208         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
11209         ndr->depth++;
11210         if (r->print_processor_name) {
11211                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
11212         }
11213         ndr->depth--;
11214         ndr->depth--;
11215 }
11216
11217 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
11218 {
11219         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11220         if (ndr_flags & NDR_SCALARS) {
11221                 int level = ndr_push_get_switch_value(ndr, r);
11222                 switch (level) {
11223                         case 1: {
11224                                 NDR_CHECK(ndr_push_align(ndr, 4));
11225                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11226                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11227                         break; }
11228
11229                         default: {
11230                         break; }
11231
11232                 }
11233         }
11234         if (ndr_flags & NDR_BUFFERS) {
11235                 int level = ndr_push_get_switch_value(ndr, r);
11236                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11237                 switch (level) {
11238                         case 1:
11239                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11240                         break;
11241
11242                         default:
11243                         break;
11244
11245                 }
11246         }
11247         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11248         return NDR_ERR_SUCCESS;
11249 }
11250
11251 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
11252 {
11253         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11254         int level;
11255         level = ndr_pull_get_switch_value(ndr, r);
11256         if (ndr_flags & NDR_SCALARS) {
11257                 switch (level) {
11258                         case 1: {
11259                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11260                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11261                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11262                         break; }
11263
11264                         default: {
11265                         break; }
11266
11267                 }
11268         }
11269         if (ndr_flags & NDR_BUFFERS) {
11270                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11271                 switch (level) {
11272                         case 1:
11273                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11274                         break;
11275
11276                         default:
11277                         break;
11278
11279                 }
11280         }
11281         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11282         return NDR_ERR_SUCCESS;
11283 }
11284
11285 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
11286 {
11287         int level;
11288         level = ndr_print_get_switch_value(ndr, r);
11289         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
11290         switch (level) {
11291                 case 1:
11292                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
11293                 break;
11294
11295                 default:
11296                 break;
11297
11298         }
11299 }
11300
11301 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11302 {
11303         if (ndr_flags & NDR_SCALARS) {
11304                 NDR_CHECK(ndr_push_align(ndr, 4));
11305                 {
11306                         uint32_t _flags_save_string = ndr->flags;
11307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11308                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
11309                         ndr->flags = _flags_save_string;
11310                 }
11311         }
11312         if (ndr_flags & NDR_BUFFERS) {
11313         }
11314         return NDR_ERR_SUCCESS;
11315 }
11316
11317 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
11318 {
11319         if (ndr_flags & NDR_SCALARS) {
11320                 NDR_CHECK(ndr_pull_align(ndr, 4));
11321                 {
11322                         uint32_t _flags_save_string = ndr->flags;
11323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11324                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
11325                         ndr->flags = _flags_save_string;
11326                 }
11327         }
11328         if (ndr_flags & NDR_BUFFERS) {
11329         }
11330         return NDR_ERR_SUCCESS;
11331 }
11332
11333 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11334 {
11335         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
11336         ndr->depth++;
11337         ndr_print_string(ndr, "directory_name", r->directory_name);
11338         ndr->depth--;
11339 }
11340
11341 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
11342 {
11343         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
11344 }
11345
11346 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
11347 {
11348         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11349         if (ndr_flags & NDR_SCALARS) {
11350                 int level = ndr_push_get_switch_value(ndr, r);
11351                 switch (level) {
11352                         case 1: {
11353                                 NDR_CHECK(ndr_push_align(ndr, 4));
11354                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11355                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11356                         break; }
11357
11358                         default: {
11359                         break; }
11360
11361                 }
11362         }
11363         if (ndr_flags & NDR_BUFFERS) {
11364                 int level = ndr_push_get_switch_value(ndr, r);
11365                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11366                 switch (level) {
11367                         case 1:
11368                         break;
11369
11370                         default:
11371                         break;
11372
11373                 }
11374         }
11375         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11376         return NDR_ERR_SUCCESS;
11377 }
11378
11379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
11380 {
11381         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11382         int level;
11383         level = ndr_pull_get_switch_value(ndr, r);
11384         if (ndr_flags & NDR_SCALARS) {
11385                 switch (level) {
11386                         case 1: {
11387                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11388                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11389                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11390                         break; }
11391
11392                         default: {
11393                         break; }
11394
11395                 }
11396         }
11397         if (ndr_flags & NDR_BUFFERS) {
11398                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11399                 switch (level) {
11400                         case 1:
11401                         break;
11402
11403                         default:
11404                         break;
11405
11406                 }
11407         }
11408         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11409         return NDR_ERR_SUCCESS;
11410 }
11411
11412 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
11413 {
11414         int level;
11415         level = ndr_print_get_switch_value(ndr, r);
11416         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
11417         switch (level) {
11418                 case 1:
11419                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
11420                 break;
11421
11422                 default:
11423                 break;
11424
11425         }
11426 }
11427
11428 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11429 {
11430         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
11431 }
11432
11433 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
11434 {
11435         if (ndr_flags & NDR_SCALARS) {
11436                 NDR_CHECK(ndr_push_align(ndr, 4));
11437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
11438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
11439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
11440         }
11441         if (ndr_flags & NDR_BUFFERS) {
11442                 if (r->document_name) {
11443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11447                 }
11448                 if (r->output_file) {
11449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11453                 }
11454                 if (r->datatype) {
11455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11459                 }
11460         }
11461         return NDR_ERR_SUCCESS;
11462 }
11463
11464 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
11465 {
11466         uint32_t _ptr_document_name;
11467         TALLOC_CTX *_mem_save_document_name_0;
11468         uint32_t _ptr_output_file;
11469         TALLOC_CTX *_mem_save_output_file_0;
11470         uint32_t _ptr_datatype;
11471         TALLOC_CTX *_mem_save_datatype_0;
11472         if (ndr_flags & NDR_SCALARS) {
11473                 NDR_CHECK(ndr_pull_align(ndr, 4));
11474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
11475                 if (_ptr_document_name) {
11476                         NDR_PULL_ALLOC(ndr, r->document_name);
11477                 } else {
11478                         r->document_name = NULL;
11479                 }
11480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
11481                 if (_ptr_output_file) {
11482                         NDR_PULL_ALLOC(ndr, r->output_file);
11483                 } else {
11484                         r->output_file = NULL;
11485                 }
11486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
11487                 if (_ptr_datatype) {
11488                         NDR_PULL_ALLOC(ndr, r->datatype);
11489                 } else {
11490                         r->datatype = NULL;
11491                 }
11492         }
11493         if (ndr_flags & NDR_BUFFERS) {
11494                 if (r->document_name) {
11495                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11496                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
11497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
11498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
11499                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
11500                                 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));
11501                         }
11502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
11503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
11504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
11505                 }
11506                 if (r->output_file) {
11507                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11508                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
11509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
11510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
11511                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
11512                                 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));
11513                         }
11514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
11515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
11516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
11517                 }
11518                 if (r->datatype) {
11519                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11520                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
11521                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
11522                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
11523                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
11524                                 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));
11525                         }
11526                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
11527                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
11528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
11529                 }
11530         }
11531         return NDR_ERR_SUCCESS;
11532 }
11533
11534 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
11535 {
11536         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
11537         ndr->depth++;
11538         ndr_print_ptr(ndr, "document_name", r->document_name);
11539         ndr->depth++;
11540         if (r->document_name) {
11541                 ndr_print_string(ndr, "document_name", r->document_name);
11542         }
11543         ndr->depth--;
11544         ndr_print_ptr(ndr, "output_file", r->output_file);
11545         ndr->depth++;
11546         if (r->output_file) {
11547                 ndr_print_string(ndr, "output_file", r->output_file);
11548         }
11549         ndr->depth--;
11550         ndr_print_ptr(ndr, "datatype", r->datatype);
11551         ndr->depth++;
11552         if (r->datatype) {
11553                 ndr_print_string(ndr, "datatype", r->datatype);
11554         }
11555         ndr->depth--;
11556         ndr->depth--;
11557 }
11558
11559 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
11560 {
11561         if (ndr_flags & NDR_SCALARS) {
11562                 int level = ndr_push_get_switch_value(ndr, r);
11563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11564                 switch (level) {
11565                         case 1: {
11566                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
11567                         break; }
11568
11569                         case 2: {
11570                         break; }
11571
11572                         case 3: {
11573                         break; }
11574
11575                         default: {
11576                         break; }
11577
11578                 }
11579         }
11580         if (ndr_flags & NDR_BUFFERS) {
11581                 int level = ndr_push_get_switch_value(ndr, r);
11582                 switch (level) {
11583                         case 1:
11584                                 if (r->info1) {
11585                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11586                                 }
11587                         break;
11588
11589                         case 2:
11590                         break;
11591
11592                         case 3:
11593                         break;
11594
11595                         default:
11596                         break;
11597
11598                 }
11599         }
11600         return NDR_ERR_SUCCESS;
11601 }
11602
11603 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
11604 {
11605         int level;
11606         uint32_t _level;
11607         TALLOC_CTX *_mem_save_info1_0;
11608         level = ndr_pull_get_switch_value(ndr, r);
11609         if (ndr_flags & NDR_SCALARS) {
11610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11611                 if (_level != level) {
11612                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11613                 }
11614                 switch (level) {
11615                         case 1: {
11616                                 uint32_t _ptr_info1;
11617                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
11618                                 if (_ptr_info1) {
11619                                         NDR_PULL_ALLOC(ndr, r->info1);
11620                                 } else {
11621                                         r->info1 = NULL;
11622                                 }
11623                         break; }
11624
11625                         case 2: {
11626                         break; }
11627
11628                         case 3: {
11629                         break; }
11630
11631                         default: {
11632                         break; }
11633
11634                 }
11635         }
11636         if (ndr_flags & NDR_BUFFERS) {
11637                 switch (level) {
11638                         case 1:
11639                                 if (r->info1) {
11640                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11641                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
11642                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11643                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
11644                                 }
11645                         break;
11646
11647                         case 2:
11648                         break;
11649
11650                         case 3:
11651                         break;
11652
11653                         default:
11654                         break;
11655
11656                 }
11657         }
11658         return NDR_ERR_SUCCESS;
11659 }
11660
11661 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
11662 {
11663         int level;
11664         level = ndr_print_get_switch_value(ndr, r);
11665         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
11666         switch (level) {
11667                 case 1:
11668                         ndr_print_ptr(ndr, "info1", r->info1);
11669                         ndr->depth++;
11670                         if (r->info1) {
11671                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
11672                         }
11673                         ndr->depth--;
11674                 break;
11675
11676                 case 2:
11677                 break;
11678
11679                 case 3:
11680                 break;
11681
11682                 default:
11683                 break;
11684
11685         }
11686 }
11687
11688 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
11689 {
11690         if (ndr_flags & NDR_SCALARS) {
11691                 NDR_CHECK(ndr_push_align(ndr, 4));
11692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
11693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11697                 {
11698                         uint32_t _flags_save_string = ndr->flags;
11699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11700                         {
11701                                 struct ndr_push *_ndr_extra_string;
11702                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11703                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11704                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11705                         }
11706                         ndr->flags = _flags_save_string;
11707                 }
11708         }
11709         if (ndr_flags & NDR_BUFFERS) {
11710         }
11711         return NDR_ERR_SUCCESS;
11712 }
11713
11714 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
11715 {
11716         if (ndr_flags & NDR_SCALARS) {
11717                 NDR_CHECK(ndr_pull_align(ndr, 4));
11718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
11723                 {
11724                         uint32_t _flags_save_string = ndr->flags;
11725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11726                         {
11727                                 struct ndr_pull *_ndr_extra_string;
11728                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11729                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11730                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11731                         }
11732                         ndr->flags = _flags_save_string;
11733                 }
11734         }
11735         if (ndr_flags & NDR_BUFFERS) {
11736         }
11737         return NDR_ERR_SUCCESS;
11738 }
11739
11740 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
11741 {
11742         ndr_print_struct(ndr, name, "spoolss_OSVersion");
11743         ndr->depth++;
11744         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);
11745         ndr_print_uint32(ndr, "major", r->major);
11746         ndr_print_uint32(ndr, "minor", r->minor);
11747         ndr_print_uint32(ndr, "build", r->build);
11748         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
11749         ndr_print_string(ndr, "extra_string", r->extra_string);
11750         ndr->depth--;
11751 }
11752
11753 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
11754 {
11755         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
11756 }
11757
11758 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
11759 {
11760         if (ndr_flags & NDR_SCALARS) {
11761                 NDR_CHECK(ndr_push_align(ndr, 4));
11762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
11763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11767                 {
11768                         uint32_t _flags_save_string = ndr->flags;
11769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11770                         {
11771                                 struct ndr_push *_ndr_extra_string;
11772                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11773                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11774                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11775                         }
11776                         ndr->flags = _flags_save_string;
11777                 }
11778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
11779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
11780         }
11781         if (ndr_flags & NDR_BUFFERS) {
11782         }
11783         return NDR_ERR_SUCCESS;
11784 }
11785
11786 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
11787 {
11788         if (ndr_flags & NDR_SCALARS) {
11789                 NDR_CHECK(ndr_pull_align(ndr, 4));
11790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
11795                 {
11796                         uint32_t _flags_save_string = ndr->flags;
11797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11798                         {
11799                                 struct ndr_pull *_ndr_extra_string;
11800                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11801                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11802                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11803                         }
11804                         ndr->flags = _flags_save_string;
11805                 }
11806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
11807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
11808         }
11809         if (ndr_flags & NDR_BUFFERS) {
11810         }
11811         return NDR_ERR_SUCCESS;
11812 }
11813
11814 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
11815 {
11816         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
11817         ndr->depth++;
11818         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);
11819         ndr_print_uint32(ndr, "major", r->major);
11820         ndr_print_uint32(ndr, "minor", r->minor);
11821         ndr_print_uint32(ndr, "build", r->build);
11822         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
11823         ndr_print_string(ndr, "extra_string", r->extra_string);
11824         ndr_print_uint32(ndr, "unknown2", r->unknown2);
11825         ndr_print_uint32(ndr, "unknown3", r->unknown3);
11826         ndr->depth--;
11827 }
11828
11829 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
11830 {
11831         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
11832 }
11833
11834 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
11835 {
11836         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11837         return NDR_ERR_SUCCESS;
11838 }
11839
11840 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
11841 {
11842         uint32_t v;
11843         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11844         *r = v;
11845         return NDR_ERR_SUCCESS;
11846 }
11847
11848 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
11849 {
11850         const char *val = NULL;
11851
11852         switch (r) {
11853                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
11854                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
11855                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
11856                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
11857                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
11858         }
11859         ndr_print_enum(ndr, name, "ENUM", val, r);
11860 }
11861
11862 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
11863 {
11864         if (ndr_flags & NDR_SCALARS) {
11865                 int level = ndr_push_get_switch_value(ndr, r);
11866                 switch (level) {
11867                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11868                         break; }
11869
11870                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11871                                 {
11872                                         uint32_t _flags_save_string = ndr->flags;
11873                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11874                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
11875                                         ndr->flags = _flags_save_string;
11876                                 }
11877                         break; }
11878
11879                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11880                                 {
11881                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11882                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11883                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11884                                         ndr->flags = _flags_save_DATA_BLOB;
11885                                 }
11886                         break; }
11887
11888                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11889                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
11890                         break; }
11891
11892                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11893                                 {
11894                                         uint32_t _flags_save_string_array = ndr->flags;
11895                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11896                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
11897                                         ndr->flags = _flags_save_string_array;
11898                                 }
11899                         break; }
11900
11901                         default: {
11902                                 {
11903                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11904                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11905                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
11906                                         ndr->flags = _flags_save_DATA_BLOB;
11907                                 }
11908                         break; }
11909
11910                 }
11911         }
11912         if (ndr_flags & NDR_BUFFERS) {
11913                 int level = ndr_push_get_switch_value(ndr, r);
11914                 switch (level) {
11915                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11916                         break;
11917
11918                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11919                         break;
11920
11921                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11922                         break;
11923
11924                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11925                         break;
11926
11927                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11928                         break;
11929
11930                         default:
11931                         break;
11932
11933                 }
11934         }
11935         return NDR_ERR_SUCCESS;
11936 }
11937
11938 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
11939 {
11940         int level;
11941         level = ndr_pull_get_switch_value(ndr, r);
11942         if (ndr_flags & NDR_SCALARS) {
11943                 switch (level) {
11944                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11945                         break; }
11946
11947                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11948                                 {
11949                                         uint32_t _flags_save_string = ndr->flags;
11950                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11951                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
11952                                         ndr->flags = _flags_save_string;
11953                                 }
11954                         break; }
11955
11956                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11957                                 {
11958                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11959                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11960                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
11961                                         ndr->flags = _flags_save_DATA_BLOB;
11962                                 }
11963                         break; }
11964
11965                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11966                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
11967                         break; }
11968
11969                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11970                                 {
11971                                         uint32_t _flags_save_string_array = ndr->flags;
11972                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11973                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
11974                                         ndr->flags = _flags_save_string_array;
11975                                 }
11976                         break; }
11977
11978                         default: {
11979                                 {
11980                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11981                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11982                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
11983                                         ndr->flags = _flags_save_DATA_BLOB;
11984                                 }
11985                         break; }
11986
11987                 }
11988         }
11989         if (ndr_flags & NDR_BUFFERS) {
11990                 switch (level) {
11991                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11992                         break;
11993
11994                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11995                         break;
11996
11997                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11998                         break;
11999
12000                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
12001                         break;
12002
12003                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
12004                         break;
12005
12006                         default:
12007                         break;
12008
12009                 }
12010         }
12011         return NDR_ERR_SUCCESS;
12012 }
12013
12014 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
12015 {
12016         int level;
12017         level = ndr_print_get_switch_value(ndr, r);
12018         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
12019         switch (level) {
12020                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
12021                 break;
12022
12023                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
12024                         ndr_print_string(ndr, "string", r->string);
12025                 break;
12026
12027                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
12028                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
12029                 break;
12030
12031                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
12032                         ndr_print_uint32(ndr, "value", r->value);
12033                 break;
12034
12035                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
12036                         ndr_print_string_array(ndr, "string_array", r->string_array);
12037                 break;
12038
12039                 default:
12040                         ndr_print_DATA_BLOB(ndr, "data", r->data);
12041                 break;
12042
12043         }
12044 }
12045
12046 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12047 {
12048         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
12049 }
12050
12051 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
12052 {
12053         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12054         return NDR_ERR_SUCCESS;
12055 }
12056
12057 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
12058 {
12059         uint32_t v;
12060         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12061         *r = v;
12062         return NDR_ERR_SUCCESS;
12063 }
12064
12065 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
12066 {
12067         const char *val = NULL;
12068
12069         switch (r) {
12070                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
12071                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
12072                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
12073         }
12074         ndr_print_enum(ndr, name, "ENUM", val, r);
12075 }
12076
12077 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
12078 {
12079         if (ndr_flags & NDR_SCALARS) {
12080                 NDR_CHECK(ndr_push_align(ndr, 4));
12081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
12082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
12083         }
12084         if (ndr_flags & NDR_BUFFERS) {
12085         }
12086         return NDR_ERR_SUCCESS;
12087 }
12088
12089 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
12090 {
12091         if (ndr_flags & NDR_SCALARS) {
12092                 NDR_CHECK(ndr_pull_align(ndr, 4));
12093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
12094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
12095         }
12096         if (ndr_flags & NDR_BUFFERS) {
12097         }
12098         return NDR_ERR_SUCCESS;
12099 }
12100
12101 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
12102 {
12103         ndr_print_struct(ndr, name, "spoolss_FormSize");
12104         ndr->depth++;
12105         ndr_print_uint32(ndr, "width", r->width);
12106         ndr_print_uint32(ndr, "height", r->height);
12107         ndr->depth--;
12108 }
12109
12110 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
12111 {
12112         if (ndr_flags & NDR_SCALARS) {
12113                 NDR_CHECK(ndr_push_align(ndr, 4));
12114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
12115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
12116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
12117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
12118         }
12119         if (ndr_flags & NDR_BUFFERS) {
12120         }
12121         return NDR_ERR_SUCCESS;
12122 }
12123
12124 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
12125 {
12126         if (ndr_flags & NDR_SCALARS) {
12127                 NDR_CHECK(ndr_pull_align(ndr, 4));
12128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
12129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
12130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
12131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
12132         }
12133         if (ndr_flags & NDR_BUFFERS) {
12134         }
12135         return NDR_ERR_SUCCESS;
12136 }
12137
12138 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
12139 {
12140         ndr_print_struct(ndr, name, "spoolss_FormArea");
12141         ndr->depth++;
12142         ndr_print_uint32(ndr, "left", r->left);
12143         ndr_print_uint32(ndr, "top", r->top);
12144         ndr_print_uint32(ndr, "right", r->right);
12145         ndr_print_uint32(ndr, "bottom", r->bottom);
12146         ndr->depth--;
12147 }
12148
12149 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
12150 {
12151         if (ndr_flags & NDR_SCALARS) {
12152                 NDR_CHECK(ndr_push_align(ndr, 4));
12153                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
12154                 {
12155                         uint32_t _flags_save_string = ndr->flags;
12156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12157                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
12158                         ndr->flags = _flags_save_string;
12159                 }
12160                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12161                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12162         }
12163         if (ndr_flags & NDR_BUFFERS) {
12164                 {
12165                         uint32_t _flags_save_string = ndr->flags;
12166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12167                         if (r->form_name) {
12168                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
12169                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
12170                         }
12171                         ndr->flags = _flags_save_string;
12172                 }
12173         }
12174         return NDR_ERR_SUCCESS;
12175 }
12176
12177 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
12178 {
12179         uint32_t _ptr_form_name;
12180         TALLOC_CTX *_mem_save_form_name_0;
12181         if (ndr_flags & NDR_SCALARS) {
12182                 NDR_CHECK(ndr_pull_align(ndr, 4));
12183                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
12184                 {
12185                         uint32_t _flags_save_string = ndr->flags;
12186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12187                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
12188                         if (_ptr_form_name) {
12189                                 NDR_PULL_ALLOC(ndr, r->form_name);
12190                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
12191                         } else {
12192                                 r->form_name = NULL;
12193                         }
12194                         ndr->flags = _flags_save_string;
12195                 }
12196                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12197                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12198         }
12199         if (ndr_flags & NDR_BUFFERS) {
12200                 {
12201                         uint32_t _flags_save_string = ndr->flags;
12202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12203                         if (r->form_name) {
12204                                 uint32_t _relative_save_offset;
12205                                 _relative_save_offset = ndr->offset;
12206                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
12207                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12208                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12209                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
12210                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12211                                 ndr->offset = _relative_save_offset;
12212                         }
12213                         ndr->flags = _flags_save_string;
12214                 }
12215         }
12216         return NDR_ERR_SUCCESS;
12217 }
12218
12219 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
12220 {
12221         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
12222         ndr->depth++;
12223         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12224         ndr_print_ptr(ndr, "form_name", r->form_name);
12225         ndr->depth++;
12226         if (r->form_name) {
12227                 ndr_print_string(ndr, "form_name", r->form_name);
12228         }
12229         ndr->depth--;
12230         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12231         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12232         ndr->depth--;
12233 }
12234
12235 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12236 {
12237         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12238         return NDR_ERR_SUCCESS;
12239 }
12240
12241 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12242 {
12243         uint32_t v;
12244         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12245         *r = v;
12246         return NDR_ERR_SUCCESS;
12247 }
12248
12249 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
12250 {
12251         ndr_print_uint32(ndr, name, r);
12252         ndr->depth++;
12253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
12254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
12255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
12256         ndr->depth--;
12257 }
12258
12259 static enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
12260 {
12261         if (ndr_flags & NDR_SCALARS) {
12262                 NDR_CHECK(ndr_push_align(ndr, 4));
12263                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
12264                 {
12265                         uint32_t _flags_save_string = ndr->flags;
12266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12267                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
12268                         ndr->flags = _flags_save_string;
12269                 }
12270                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12271                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12272                 {
12273                         uint32_t _flags_save_string = ndr->flags;
12274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12275                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
12276                         ndr->flags = _flags_save_string;
12277                 }
12278                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
12279                 {
12280                         uint32_t _flags_save_string = ndr->flags;
12281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12282                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
12283                         ndr->flags = _flags_save_string;
12284                 }
12285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
12286                 {
12287                         uint32_t _flags_save_string = ndr->flags;
12288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12289                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
12290                         ndr->flags = _flags_save_string;
12291                 }
12292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
12293         }
12294         if (ndr_flags & NDR_BUFFERS) {
12295                 {
12296                         uint32_t _flags_save_string = ndr->flags;
12297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12298                         if (r->form_name) {
12299                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
12300                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
12301                         }
12302                         ndr->flags = _flags_save_string;
12303                 }
12304                 {
12305                         uint32_t _flags_save_string = ndr->flags;
12306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12307                         if (r->keyword) {
12308                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
12309                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
12310                         }
12311                         ndr->flags = _flags_save_string;
12312                 }
12313                 {
12314                         uint32_t _flags_save_string = ndr->flags;
12315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12316                         if (r->mui_dll) {
12317                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
12318                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
12319                         }
12320                         ndr->flags = _flags_save_string;
12321                 }
12322                 {
12323                         uint32_t _flags_save_string = ndr->flags;
12324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12325                         if (r->display_name) {
12326                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
12327                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
12328                         }
12329                         ndr->flags = _flags_save_string;
12330                 }
12331         }
12332         return NDR_ERR_SUCCESS;
12333 }
12334
12335 static enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
12336 {
12337         uint32_t _ptr_form_name;
12338         TALLOC_CTX *_mem_save_form_name_0;
12339         uint32_t _ptr_keyword;
12340         TALLOC_CTX *_mem_save_keyword_0;
12341         uint32_t _ptr_mui_dll;
12342         TALLOC_CTX *_mem_save_mui_dll_0;
12343         uint32_t _ptr_display_name;
12344         TALLOC_CTX *_mem_save_display_name_0;
12345         if (ndr_flags & NDR_SCALARS) {
12346                 NDR_CHECK(ndr_pull_align(ndr, 4));
12347                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
12348                 {
12349                         uint32_t _flags_save_string = ndr->flags;
12350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
12352                         if (_ptr_form_name) {
12353                                 NDR_PULL_ALLOC(ndr, r->form_name);
12354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
12355                         } else {
12356                                 r->form_name = NULL;
12357                         }
12358                         ndr->flags = _flags_save_string;
12359                 }
12360                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12361                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12362                 {
12363                         uint32_t _flags_save_string = ndr->flags;
12364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
12366                         if (_ptr_keyword) {
12367                                 NDR_PULL_ALLOC(ndr, r->keyword);
12368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
12369                         } else {
12370                                 r->keyword = NULL;
12371                         }
12372                         ndr->flags = _flags_save_string;
12373                 }
12374                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
12375                 {
12376                         uint32_t _flags_save_string = ndr->flags;
12377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12378                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
12379                         if (_ptr_mui_dll) {
12380                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
12381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
12382                         } else {
12383                                 r->mui_dll = NULL;
12384                         }
12385                         ndr->flags = _flags_save_string;
12386                 }
12387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
12388                 {
12389                         uint32_t _flags_save_string = ndr->flags;
12390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12391                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
12392                         if (_ptr_display_name) {
12393                                 NDR_PULL_ALLOC(ndr, r->display_name);
12394                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
12395                         } else {
12396                                 r->display_name = NULL;
12397                         }
12398                         ndr->flags = _flags_save_string;
12399                 }
12400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
12401         }
12402         if (ndr_flags & NDR_BUFFERS) {
12403                 {
12404                         uint32_t _flags_save_string = ndr->flags;
12405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12406                         if (r->form_name) {
12407                                 uint32_t _relative_save_offset;
12408                                 _relative_save_offset = ndr->offset;
12409                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
12410                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12411                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12412                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
12413                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12414                                 ndr->offset = _relative_save_offset;
12415                         }
12416                         ndr->flags = _flags_save_string;
12417                 }
12418                 {
12419                         uint32_t _flags_save_string = ndr->flags;
12420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12421                         if (r->keyword) {
12422                                 uint32_t _relative_save_offset;
12423                                 _relative_save_offset = ndr->offset;
12424                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
12425                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
12426                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
12427                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
12428                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
12429                                 ndr->offset = _relative_save_offset;
12430                         }
12431                         ndr->flags = _flags_save_string;
12432                 }
12433                 {
12434                         uint32_t _flags_save_string = ndr->flags;
12435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12436                         if (r->mui_dll) {
12437                                 uint32_t _relative_save_offset;
12438                                 _relative_save_offset = ndr->offset;
12439                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
12440                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
12441                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
12442                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
12443                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
12444                                 ndr->offset = _relative_save_offset;
12445                         }
12446                         ndr->flags = _flags_save_string;
12447                 }
12448                 {
12449                         uint32_t _flags_save_string = ndr->flags;
12450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12451                         if (r->display_name) {
12452                                 uint32_t _relative_save_offset;
12453                                 _relative_save_offset = ndr->offset;
12454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
12455                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12456                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
12457                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
12458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
12459                                 ndr->offset = _relative_save_offset;
12460                         }
12461                         ndr->flags = _flags_save_string;
12462                 }
12463         }
12464         return NDR_ERR_SUCCESS;
12465 }
12466
12467 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
12468 {
12469         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
12470         ndr->depth++;
12471         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12472         ndr_print_ptr(ndr, "form_name", r->form_name);
12473         ndr->depth++;
12474         if (r->form_name) {
12475                 ndr_print_string(ndr, "form_name", r->form_name);
12476         }
12477         ndr->depth--;
12478         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12479         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12480         ndr_print_ptr(ndr, "keyword", r->keyword);
12481         ndr->depth++;
12482         if (r->keyword) {
12483                 ndr_print_string(ndr, "keyword", r->keyword);
12484         }
12485         ndr->depth--;
12486         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
12487         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
12488         ndr->depth++;
12489         if (r->mui_dll) {
12490                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
12491         }
12492         ndr->depth--;
12493         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
12494         ndr_print_ptr(ndr, "display_name", r->display_name);
12495         ndr->depth++;
12496         if (r->display_name) {
12497                 ndr_print_string(ndr, "display_name", r->display_name);
12498         }
12499         ndr->depth--;
12500         ndr_print_uint32(ndr, "lang_id", r->lang_id);
12501         ndr->depth--;
12502 }
12503
12504 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
12505 {
12506         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12507         if (ndr_flags & NDR_SCALARS) {
12508                 int level = ndr_push_get_switch_value(ndr, r);
12509                 switch (level) {
12510                         case 1: {
12511                                 NDR_CHECK(ndr_push_align(ndr, 4));
12512                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12513                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12514                         break; }
12515
12516                         case 2: {
12517                                 NDR_CHECK(ndr_push_align(ndr, 4));
12518                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12519                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
12520                         break; }
12521
12522                         default: {
12523                         break; }
12524
12525                 }
12526         }
12527         if (ndr_flags & NDR_BUFFERS) {
12528                 int level = ndr_push_get_switch_value(ndr, r);
12529                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12530                 switch (level) {
12531                         case 1:
12532                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12533                         break;
12534
12535                         case 2:
12536                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
12537                         break;
12538
12539                         default:
12540                         break;
12541
12542                 }
12543         }
12544         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12545         return NDR_ERR_SUCCESS;
12546 }
12547
12548 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
12549 {
12550         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12551         int level;
12552         level = ndr_pull_get_switch_value(ndr, r);
12553         if (ndr_flags & NDR_SCALARS) {
12554                 switch (level) {
12555                         case 1: {
12556                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12557                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12558                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12559                         break; }
12560
12561                         case 2: {
12562                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12563                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12564                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
12565                         break; }
12566
12567                         default: {
12568                         break; }
12569
12570                 }
12571         }
12572         if (ndr_flags & NDR_BUFFERS) {
12573                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12574                 switch (level) {
12575                         case 1:
12576                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12577                         break;
12578
12579                         case 2:
12580                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
12581                         break;
12582
12583                         default:
12584                         break;
12585
12586                 }
12587         }
12588         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12589         return NDR_ERR_SUCCESS;
12590 }
12591
12592 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
12593 {
12594         int level;
12595         level = ndr_print_get_switch_value(ndr, r);
12596         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
12597         switch (level) {
12598                 case 1:
12599                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
12600                 break;
12601
12602                 case 2:
12603                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
12604                 break;
12605
12606                 default:
12607                 break;
12608
12609         }
12610 }
12611
12612 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12613 {
12614         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
12615 }
12616
12617 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
12618 {
12619         if (ndr_flags & NDR_SCALARS) {
12620                 NDR_CHECK(ndr_push_align(ndr, 4));
12621                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
12622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
12623                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12624                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12625         }
12626         if (ndr_flags & NDR_BUFFERS) {
12627                 if (r->form_name) {
12628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12631                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12632                 }
12633         }
12634         return NDR_ERR_SUCCESS;
12635 }
12636
12637 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
12638 {
12639         uint32_t _ptr_form_name;
12640         TALLOC_CTX *_mem_save_form_name_0;
12641         if (ndr_flags & NDR_SCALARS) {
12642                 NDR_CHECK(ndr_pull_align(ndr, 4));
12643                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
12644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
12645                 if (_ptr_form_name) {
12646                         NDR_PULL_ALLOC(ndr, r->form_name);
12647                 } else {
12648                         r->form_name = NULL;
12649                 }
12650                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12651                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12652         }
12653         if (ndr_flags & NDR_BUFFERS) {
12654                 if (r->form_name) {
12655                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12656                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
12658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
12659                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
12660                                 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));
12661                         }
12662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
12663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
12664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12665                 }
12666         }
12667         return NDR_ERR_SUCCESS;
12668 }
12669
12670 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
12671 {
12672         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
12673         ndr->depth++;
12674         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12675         ndr_print_ptr(ndr, "form_name", r->form_name);
12676         ndr->depth++;
12677         if (r->form_name) {
12678                 ndr_print_string(ndr, "form_name", r->form_name);
12679         }
12680         ndr->depth--;
12681         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12682         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12683         ndr->depth--;
12684 }
12685
12686 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
12687 {
12688         if (ndr_flags & NDR_SCALARS) {
12689                 int level = ndr_push_get_switch_value(ndr, r);
12690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12691                 switch (level) {
12692                         case 1: {
12693                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
12694                         break; }
12695
12696                         default:
12697                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12698                 }
12699         }
12700         if (ndr_flags & NDR_BUFFERS) {
12701                 int level = ndr_push_get_switch_value(ndr, r);
12702                 switch (level) {
12703                         case 1:
12704                                 if (r->info1) {
12705                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12706                                 }
12707                         break;
12708
12709                         default:
12710                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12711                 }
12712         }
12713         return NDR_ERR_SUCCESS;
12714 }
12715
12716 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
12717 {
12718         int level;
12719         uint32_t _level;
12720         TALLOC_CTX *_mem_save_info1_0;
12721         level = ndr_pull_get_switch_value(ndr, r);
12722         if (ndr_flags & NDR_SCALARS) {
12723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12724                 if (_level != level) {
12725                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12726                 }
12727                 switch (level) {
12728                         case 1: {
12729                                 uint32_t _ptr_info1;
12730                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
12731                                 if (_ptr_info1) {
12732                                         NDR_PULL_ALLOC(ndr, r->info1);
12733                                 } else {
12734                                         r->info1 = NULL;
12735                                 }
12736                         break; }
12737
12738                         default:
12739                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12740                 }
12741         }
12742         if (ndr_flags & NDR_BUFFERS) {
12743                 switch (level) {
12744                         case 1:
12745                                 if (r->info1) {
12746                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12747                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
12748                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12749                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
12750                                 }
12751                         break;
12752
12753                         default:
12754                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12755                 }
12756         }
12757         return NDR_ERR_SUCCESS;
12758 }
12759
12760 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
12761 {
12762         int level;
12763         level = ndr_print_get_switch_value(ndr, r);
12764         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
12765         switch (level) {
12766                 case 1:
12767                         ndr_print_ptr(ndr, "info1", r->info1);
12768                         ndr->depth++;
12769                         if (r->info1) {
12770                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
12771                         }
12772                         ndr->depth--;
12773                 break;
12774
12775                 default:
12776                         ndr_print_bad_level(ndr, name, level);
12777         }
12778 }
12779
12780 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
12781 {
12782         if (ndr_flags & NDR_SCALARS) {
12783                 NDR_CHECK(ndr_push_align(ndr, 4));
12784                 {
12785                         uint32_t _flags_save_string = ndr->flags;
12786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12787                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12788                         ndr->flags = _flags_save_string;
12789                 }
12790         }
12791         if (ndr_flags & NDR_BUFFERS) {
12792                 {
12793                         uint32_t _flags_save_string = ndr->flags;
12794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12795                         if (r->port_name) {
12796                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12797                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12798                         }
12799                         ndr->flags = _flags_save_string;
12800                 }
12801         }
12802         return NDR_ERR_SUCCESS;
12803 }
12804
12805 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
12806 {
12807         uint32_t _ptr_port_name;
12808         TALLOC_CTX *_mem_save_port_name_0;
12809         if (ndr_flags & NDR_SCALARS) {
12810                 NDR_CHECK(ndr_pull_align(ndr, 4));
12811                 {
12812                         uint32_t _flags_save_string = ndr->flags;
12813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12814                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12815                         if (_ptr_port_name) {
12816                                 NDR_PULL_ALLOC(ndr, r->port_name);
12817                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12818                         } else {
12819                                 r->port_name = NULL;
12820                         }
12821                         ndr->flags = _flags_save_string;
12822                 }
12823         }
12824         if (ndr_flags & NDR_BUFFERS) {
12825                 {
12826                         uint32_t _flags_save_string = ndr->flags;
12827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12828                         if (r->port_name) {
12829                                 uint32_t _relative_save_offset;
12830                                 _relative_save_offset = ndr->offset;
12831                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12832                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12833                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12834                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12835                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12836                                 ndr->offset = _relative_save_offset;
12837                         }
12838                         ndr->flags = _flags_save_string;
12839                 }
12840         }
12841         return NDR_ERR_SUCCESS;
12842 }
12843
12844 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
12845 {
12846         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
12847         ndr->depth++;
12848         ndr_print_ptr(ndr, "port_name", r->port_name);
12849         ndr->depth++;
12850         if (r->port_name) {
12851                 ndr_print_string(ndr, "port_name", r->port_name);
12852         }
12853         ndr->depth--;
12854         ndr->depth--;
12855 }
12856
12857 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12858 {
12859         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12860         return NDR_ERR_SUCCESS;
12861 }
12862
12863 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12864 {
12865         uint32_t v;
12866         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12867         *r = v;
12868         return NDR_ERR_SUCCESS;
12869 }
12870
12871 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
12872 {
12873         ndr_print_uint32(ndr, name, r);
12874         ndr->depth++;
12875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
12876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
12877         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
12878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
12879         ndr->depth--;
12880 }
12881
12882 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
12883 {
12884         if (ndr_flags & NDR_SCALARS) {
12885                 NDR_CHECK(ndr_push_align(ndr, 4));
12886                 {
12887                         uint32_t _flags_save_string = ndr->flags;
12888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12889                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12890                         ndr->flags = _flags_save_string;
12891                 }
12892                 {
12893                         uint32_t _flags_save_string = ndr->flags;
12894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12895                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12896                         ndr->flags = _flags_save_string;
12897                 }
12898                 {
12899                         uint32_t _flags_save_string = ndr->flags;
12900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12901                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
12902                         ndr->flags = _flags_save_string;
12903                 }
12904                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
12905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12906         }
12907         if (ndr_flags & NDR_BUFFERS) {
12908                 {
12909                         uint32_t _flags_save_string = ndr->flags;
12910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12911                         if (r->port_name) {
12912                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12913                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12914                         }
12915                         ndr->flags = _flags_save_string;
12916                 }
12917                 {
12918                         uint32_t _flags_save_string = ndr->flags;
12919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12920                         if (r->monitor_name) {
12921                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12922                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12923                         }
12924                         ndr->flags = _flags_save_string;
12925                 }
12926                 {
12927                         uint32_t _flags_save_string = ndr->flags;
12928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12929                         if (r->description) {
12930                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
12931                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
12932                         }
12933                         ndr->flags = _flags_save_string;
12934                 }
12935         }
12936         return NDR_ERR_SUCCESS;
12937 }
12938
12939 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
12940 {
12941         uint32_t _ptr_port_name;
12942         TALLOC_CTX *_mem_save_port_name_0;
12943         uint32_t _ptr_monitor_name;
12944         TALLOC_CTX *_mem_save_monitor_name_0;
12945         uint32_t _ptr_description;
12946         TALLOC_CTX *_mem_save_description_0;
12947         if (ndr_flags & NDR_SCALARS) {
12948                 NDR_CHECK(ndr_pull_align(ndr, 4));
12949                 {
12950                         uint32_t _flags_save_string = ndr->flags;
12951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12952                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12953                         if (_ptr_port_name) {
12954                                 NDR_PULL_ALLOC(ndr, r->port_name);
12955                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12956                         } else {
12957                                 r->port_name = NULL;
12958                         }
12959                         ndr->flags = _flags_save_string;
12960                 }
12961                 {
12962                         uint32_t _flags_save_string = ndr->flags;
12963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12964                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12965                         if (_ptr_monitor_name) {
12966                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12967                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12968                         } else {
12969                                 r->monitor_name = NULL;
12970                         }
12971                         ndr->flags = _flags_save_string;
12972                 }
12973                 {
12974                         uint32_t _flags_save_string = ndr->flags;
12975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12976                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
12977                         if (_ptr_description) {
12978                                 NDR_PULL_ALLOC(ndr, r->description);
12979                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
12980                         } else {
12981                                 r->description = NULL;
12982                         }
12983                         ndr->flags = _flags_save_string;
12984                 }
12985                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
12986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12987         }
12988         if (ndr_flags & NDR_BUFFERS) {
12989                 {
12990                         uint32_t _flags_save_string = ndr->flags;
12991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12992                         if (r->port_name) {
12993                                 uint32_t _relative_save_offset;
12994                                 _relative_save_offset = ndr->offset;
12995                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12996                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12997                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12998                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12999                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
13000                                 ndr->offset = _relative_save_offset;
13001                         }
13002                         ndr->flags = _flags_save_string;
13003                 }
13004                 {
13005                         uint32_t _flags_save_string = ndr->flags;
13006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13007                         if (r->monitor_name) {
13008                                 uint32_t _relative_save_offset;
13009                                 _relative_save_offset = ndr->offset;
13010                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13011                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13012                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13013                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13014                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13015                                 ndr->offset = _relative_save_offset;
13016                         }
13017                         ndr->flags = _flags_save_string;
13018                 }
13019                 {
13020                         uint32_t _flags_save_string = ndr->flags;
13021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13022                         if (r->description) {
13023                                 uint32_t _relative_save_offset;
13024                                 _relative_save_offset = ndr->offset;
13025                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
13026                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
13027                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
13028                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
13029                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
13030                                 ndr->offset = _relative_save_offset;
13031                         }
13032                         ndr->flags = _flags_save_string;
13033                 }
13034         }
13035         return NDR_ERR_SUCCESS;
13036 }
13037
13038 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
13039 {
13040         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
13041         ndr->depth++;
13042         ndr_print_ptr(ndr, "port_name", r->port_name);
13043         ndr->depth++;
13044         if (r->port_name) {
13045                 ndr_print_string(ndr, "port_name", r->port_name);
13046         }
13047         ndr->depth--;
13048         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13049         ndr->depth++;
13050         if (r->monitor_name) {
13051                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13052         }
13053         ndr->depth--;
13054         ndr_print_ptr(ndr, "description", r->description);
13055         ndr->depth++;
13056         if (r->description) {
13057                 ndr_print_string(ndr, "description", r->description);
13058         }
13059         ndr->depth--;
13060         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
13061         ndr_print_uint32(ndr, "reserved", r->reserved);
13062         ndr->depth--;
13063 }
13064
13065 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
13066 {
13067         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13068         if (ndr_flags & NDR_SCALARS) {
13069                 int level = ndr_push_get_switch_value(ndr, r);
13070                 switch (level) {
13071                         case 1: {
13072                                 NDR_CHECK(ndr_push_align(ndr, 4));
13073                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13074                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
13075                         break; }
13076
13077                         case 2: {
13078                                 NDR_CHECK(ndr_push_align(ndr, 4));
13079                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13080                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
13081                         break; }
13082
13083                         case 3: {
13084                         break; }
13085
13086                         default: {
13087                         break; }
13088
13089                 }
13090         }
13091         if (ndr_flags & NDR_BUFFERS) {
13092                 int level = ndr_push_get_switch_value(ndr, r);
13093                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13094                 switch (level) {
13095                         case 1:
13096                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
13097                         break;
13098
13099                         case 2:
13100                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
13101                         break;
13102
13103                         case 3:
13104                         break;
13105
13106                         default:
13107                         break;
13108
13109                 }
13110         }
13111         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13112         return NDR_ERR_SUCCESS;
13113 }
13114
13115 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
13116 {
13117         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13118         int level;
13119         level = ndr_pull_get_switch_value(ndr, r);
13120         if (ndr_flags & NDR_SCALARS) {
13121                 switch (level) {
13122                         case 1: {
13123                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13124                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13125                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
13126                         break; }
13127
13128                         case 2: {
13129                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13130                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13131                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
13132                         break; }
13133
13134                         case 3: {
13135                         break; }
13136
13137                         default: {
13138                         break; }
13139
13140                 }
13141         }
13142         if (ndr_flags & NDR_BUFFERS) {
13143                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13144                 switch (level) {
13145                         case 1:
13146                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
13147                         break;
13148
13149                         case 2:
13150                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
13151                         break;
13152
13153                         case 3:
13154                         break;
13155
13156                         default:
13157                         break;
13158
13159                 }
13160         }
13161         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13162         return NDR_ERR_SUCCESS;
13163 }
13164
13165 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
13166 {
13167         int level;
13168         level = ndr_print_get_switch_value(ndr, r);
13169         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
13170         switch (level) {
13171                 case 1:
13172                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
13173                 break;
13174
13175                 case 2:
13176                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
13177                 break;
13178
13179                 case 3:
13180                 break;
13181
13182                 default:
13183                 break;
13184
13185         }
13186 }
13187
13188 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
13189 {
13190         if (ndr_flags & NDR_SCALARS) {
13191                 NDR_CHECK(ndr_push_align(ndr, 4));
13192                 {
13193                         uint32_t _flags_save_string = ndr->flags;
13194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13195                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13196                         ndr->flags = _flags_save_string;
13197                 }
13198         }
13199         if (ndr_flags & NDR_BUFFERS) {
13200                 {
13201                         uint32_t _flags_save_string = ndr->flags;
13202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13203                         if (r->monitor_name) {
13204                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13205                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13206                         }
13207                         ndr->flags = _flags_save_string;
13208                 }
13209         }
13210         return NDR_ERR_SUCCESS;
13211 }
13212
13213 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
13214 {
13215         uint32_t _ptr_monitor_name;
13216         TALLOC_CTX *_mem_save_monitor_name_0;
13217         if (ndr_flags & NDR_SCALARS) {
13218                 NDR_CHECK(ndr_pull_align(ndr, 4));
13219                 {
13220                         uint32_t _flags_save_string = ndr->flags;
13221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13222                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13223                         if (_ptr_monitor_name) {
13224                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13225                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13226                         } else {
13227                                 r->monitor_name = NULL;
13228                         }
13229                         ndr->flags = _flags_save_string;
13230                 }
13231         }
13232         if (ndr_flags & NDR_BUFFERS) {
13233                 {
13234                         uint32_t _flags_save_string = ndr->flags;
13235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13236                         if (r->monitor_name) {
13237                                 uint32_t _relative_save_offset;
13238                                 _relative_save_offset = ndr->offset;
13239                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13240                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13241                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13242                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13243                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13244                                 ndr->offset = _relative_save_offset;
13245                         }
13246                         ndr->flags = _flags_save_string;
13247                 }
13248         }
13249         return NDR_ERR_SUCCESS;
13250 }
13251
13252 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
13253 {
13254         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
13255         ndr->depth++;
13256         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13257         ndr->depth++;
13258         if (r->monitor_name) {
13259                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13260         }
13261         ndr->depth--;
13262         ndr->depth--;
13263 }
13264
13265 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
13266 {
13267         if (ndr_flags & NDR_SCALARS) {
13268                 NDR_CHECK(ndr_push_align(ndr, 4));
13269                 {
13270                         uint32_t _flags_save_string = ndr->flags;
13271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13272                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13273                         ndr->flags = _flags_save_string;
13274                 }
13275                 {
13276                         uint32_t _flags_save_string = ndr->flags;
13277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13278                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
13279                         ndr->flags = _flags_save_string;
13280                 }
13281                 {
13282                         uint32_t _flags_save_string = ndr->flags;
13283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13284                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
13285                         ndr->flags = _flags_save_string;
13286                 }
13287         }
13288         if (ndr_flags & NDR_BUFFERS) {
13289                 {
13290                         uint32_t _flags_save_string = ndr->flags;
13291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13292                         if (r->monitor_name) {
13293                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13294                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13295                         }
13296                         ndr->flags = _flags_save_string;
13297                 }
13298                 {
13299                         uint32_t _flags_save_string = ndr->flags;
13300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13301                         if (r->environment) {
13302                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
13303                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
13304                         }
13305                         ndr->flags = _flags_save_string;
13306                 }
13307                 {
13308                         uint32_t _flags_save_string = ndr->flags;
13309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13310                         if (r->dll_name) {
13311                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
13312                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
13313                         }
13314                         ndr->flags = _flags_save_string;
13315                 }
13316         }
13317         return NDR_ERR_SUCCESS;
13318 }
13319
13320 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
13321 {
13322         uint32_t _ptr_monitor_name;
13323         TALLOC_CTX *_mem_save_monitor_name_0;
13324         uint32_t _ptr_environment;
13325         TALLOC_CTX *_mem_save_environment_0;
13326         uint32_t _ptr_dll_name;
13327         TALLOC_CTX *_mem_save_dll_name_0;
13328         if (ndr_flags & NDR_SCALARS) {
13329                 NDR_CHECK(ndr_pull_align(ndr, 4));
13330                 {
13331                         uint32_t _flags_save_string = ndr->flags;
13332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13333                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13334                         if (_ptr_monitor_name) {
13335                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13336                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13337                         } else {
13338                                 r->monitor_name = NULL;
13339                         }
13340                         ndr->flags = _flags_save_string;
13341                 }
13342                 {
13343                         uint32_t _flags_save_string = ndr->flags;
13344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13345                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
13346                         if (_ptr_environment) {
13347                                 NDR_PULL_ALLOC(ndr, r->environment);
13348                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
13349                         } else {
13350                                 r->environment = NULL;
13351                         }
13352                         ndr->flags = _flags_save_string;
13353                 }
13354                 {
13355                         uint32_t _flags_save_string = ndr->flags;
13356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13357                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
13358                         if (_ptr_dll_name) {
13359                                 NDR_PULL_ALLOC(ndr, r->dll_name);
13360                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
13361                         } else {
13362                                 r->dll_name = NULL;
13363                         }
13364                         ndr->flags = _flags_save_string;
13365                 }
13366         }
13367         if (ndr_flags & NDR_BUFFERS) {
13368                 {
13369                         uint32_t _flags_save_string = ndr->flags;
13370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13371                         if (r->monitor_name) {
13372                                 uint32_t _relative_save_offset;
13373                                 _relative_save_offset = ndr->offset;
13374                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13375                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13376                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13377                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13378                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13379                                 ndr->offset = _relative_save_offset;
13380                         }
13381                         ndr->flags = _flags_save_string;
13382                 }
13383                 {
13384                         uint32_t _flags_save_string = ndr->flags;
13385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13386                         if (r->environment) {
13387                                 uint32_t _relative_save_offset;
13388                                 _relative_save_offset = ndr->offset;
13389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
13390                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
13391                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
13392                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
13393                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
13394                                 ndr->offset = _relative_save_offset;
13395                         }
13396                         ndr->flags = _flags_save_string;
13397                 }
13398                 {
13399                         uint32_t _flags_save_string = ndr->flags;
13400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13401                         if (r->dll_name) {
13402                                 uint32_t _relative_save_offset;
13403                                 _relative_save_offset = ndr->offset;
13404                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
13405                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13406                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
13407                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
13408                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
13409                                 ndr->offset = _relative_save_offset;
13410                         }
13411                         ndr->flags = _flags_save_string;
13412                 }
13413         }
13414         return NDR_ERR_SUCCESS;
13415 }
13416
13417 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
13418 {
13419         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
13420         ndr->depth++;
13421         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13422         ndr->depth++;
13423         if (r->monitor_name) {
13424                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13425         }
13426         ndr->depth--;
13427         ndr_print_ptr(ndr, "environment", r->environment);
13428         ndr->depth++;
13429         if (r->environment) {
13430                 ndr_print_string(ndr, "environment", r->environment);
13431         }
13432         ndr->depth--;
13433         ndr_print_ptr(ndr, "dll_name", r->dll_name);
13434         ndr->depth++;
13435         if (r->dll_name) {
13436                 ndr_print_string(ndr, "dll_name", r->dll_name);
13437         }
13438         ndr->depth--;
13439         ndr->depth--;
13440 }
13441
13442 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
13443 {
13444         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13445         if (ndr_flags & NDR_SCALARS) {
13446                 int level = ndr_push_get_switch_value(ndr, r);
13447                 switch (level) {
13448                         case 1: {
13449                                 NDR_CHECK(ndr_push_align(ndr, 4));
13450                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13451                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
13452                         break; }
13453
13454                         case 2: {
13455                                 NDR_CHECK(ndr_push_align(ndr, 4));
13456                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13457                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
13458                         break; }
13459
13460                         default: {
13461                         break; }
13462
13463                 }
13464         }
13465         if (ndr_flags & NDR_BUFFERS) {
13466                 int level = ndr_push_get_switch_value(ndr, r);
13467                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13468                 switch (level) {
13469                         case 1:
13470                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
13471                         break;
13472
13473                         case 2:
13474                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
13475                         break;
13476
13477                         default:
13478                         break;
13479
13480                 }
13481         }
13482         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13483         return NDR_ERR_SUCCESS;
13484 }
13485
13486 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
13487 {
13488         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13489         int level;
13490         level = ndr_pull_get_switch_value(ndr, r);
13491         if (ndr_flags & NDR_SCALARS) {
13492                 switch (level) {
13493                         case 1: {
13494                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13495                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13496                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
13497                         break; }
13498
13499                         case 2: {
13500                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13501                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13502                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
13503                         break; }
13504
13505                         default: {
13506                         break; }
13507
13508                 }
13509         }
13510         if (ndr_flags & NDR_BUFFERS) {
13511                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13512                 switch (level) {
13513                         case 1:
13514                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
13515                         break;
13516
13517                         case 2:
13518                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
13519                         break;
13520
13521                         default:
13522                         break;
13523
13524                 }
13525         }
13526         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13527         return NDR_ERR_SUCCESS;
13528 }
13529
13530 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
13531 {
13532         int level;
13533         level = ndr_print_get_switch_value(ndr, r);
13534         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
13535         switch (level) {
13536                 case 1:
13537                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
13538                 break;
13539
13540                 case 2:
13541                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
13542                 break;
13543
13544                 default:
13545                 break;
13546
13547         }
13548 }
13549
13550 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13551 {
13552         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13553         return NDR_ERR_SUCCESS;
13554 }
13555
13556 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13557 {
13558         uint32_t v;
13559         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13560         *r = v;
13561         return NDR_ERR_SUCCESS;
13562 }
13563
13564 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13565 {
13566         ndr_print_uint32(ndr, name, r);
13567         ndr->depth++;
13568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
13569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
13570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
13571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
13572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
13573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
13574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
13575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
13576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
13577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
13578         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
13579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
13580         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
13581         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
13582         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
13583         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
13584         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
13585         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
13586         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
13587         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
13588         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
13589         ndr->depth--;
13590 }
13591
13592 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
13593 {
13594         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13595         return NDR_ERR_SUCCESS;
13596 }
13597
13598 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
13599 {
13600         uint16_t v;
13601         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13602         *r = v;
13603         return NDR_ERR_SUCCESS;
13604 }
13605
13606 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
13607 {
13608         const char *val = NULL;
13609
13610         switch (r) {
13611                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
13612                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
13613                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
13614                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
13615                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
13616                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
13617                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
13618                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
13619                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
13620                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
13621                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
13622                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
13623                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
13624                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
13625                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
13626                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
13627                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
13628                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
13629                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
13630                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
13631                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
13632                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
13633                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
13634                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
13635                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
13636                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
13637         }
13638         ndr_print_enum(ndr, name, "ENUM", val, r);
13639 }
13640
13641 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
13642 {
13643         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13644         return NDR_ERR_SUCCESS;
13645 }
13646
13647 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
13648 {
13649         uint16_t v;
13650         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13651         *r = v;
13652         return NDR_ERR_SUCCESS;
13653 }
13654
13655 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
13656 {
13657         const char *val = NULL;
13658
13659         switch (r) {
13660                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
13661                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
13662         }
13663         ndr_print_enum(ndr, name, "ENUM", val, r);
13664 }
13665
13666 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
13667 {
13668         uint32_t cntr_fields_1;
13669         if (ndr_flags & NDR_SCALARS) {
13670                 NDR_CHECK(ndr_push_align(ndr, 4));
13671                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13672                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
13673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
13674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
13675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
13677         }
13678         if (ndr_flags & NDR_BUFFERS) {
13679                 if (r->fields) {
13680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13681                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13682                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
13683                         }
13684                 }
13685         }
13686         return NDR_ERR_SUCCESS;
13687 }
13688
13689 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
13690 {
13691         uint32_t _ptr_fields;
13692         uint32_t cntr_fields_1;
13693         TALLOC_CTX *_mem_save_fields_0;
13694         TALLOC_CTX *_mem_save_fields_1;
13695         if (ndr_flags & NDR_SCALARS) {
13696                 NDR_CHECK(ndr_pull_align(ndr, 4));
13697                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13698                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
13699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
13700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
13701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
13703                 if (_ptr_fields) {
13704                         NDR_PULL_ALLOC(ndr, r->fields);
13705                 } else {
13706                         r->fields = NULL;
13707                 }
13708         }
13709         if (ndr_flags & NDR_BUFFERS) {
13710                 if (r->fields) {
13711                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
13712                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
13714                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
13715                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
13716                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13717                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13718                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
13719                         }
13720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
13721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
13722                 }
13723                 if (r->fields) {
13724                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
13725                 }
13726         }
13727         return NDR_ERR_SUCCESS;
13728 }
13729
13730 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
13731 {
13732         uint32_t cntr_fields_1;
13733         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
13734         ndr->depth++;
13735         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13736         ndr_print_uint16(ndr, "u1", r->u1);
13737         ndr_print_uint32(ndr, "u2", r->u2);
13738         ndr_print_uint32(ndr, "u3", r->u3);
13739         ndr_print_uint32(ndr, "count", r->count);
13740         ndr_print_ptr(ndr, "fields", r->fields);
13741         ndr->depth++;
13742         if (r->fields) {
13743                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
13744                 ndr->depth++;
13745                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
13746                         char *idx_1=NULL;
13747                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
13748                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
13749                                 free(idx_1);
13750                         }
13751                 }
13752                 ndr->depth--;
13753         }
13754         ndr->depth--;
13755         ndr->depth--;
13756 }
13757
13758 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13759 {
13760         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13761         return NDR_ERR_SUCCESS;
13762 }
13763
13764 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13765 {
13766         uint32_t v;
13767         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13768         *r = v;
13769         return NDR_ERR_SUCCESS;
13770 }
13771
13772 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13773 {
13774         ndr_print_uint32(ndr, name, r);
13775         ndr->depth++;
13776         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
13777         ndr->depth--;
13778 }
13779
13780 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
13781 {
13782         uint32_t cntr_types_1;
13783         if (ndr_flags & NDR_SCALARS) {
13784                 NDR_CHECK(ndr_push_align(ndr, 4));
13785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13786                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
13787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
13789         }
13790         if (ndr_flags & NDR_BUFFERS) {
13791                 if (r->types) {
13792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13793                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13794                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13795                         }
13796                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13797                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13798                         }
13799                 }
13800         }
13801         return NDR_ERR_SUCCESS;
13802 }
13803
13804 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
13805 {
13806         uint32_t _ptr_types;
13807         uint32_t cntr_types_1;
13808         TALLOC_CTX *_mem_save_types_0;
13809         TALLOC_CTX *_mem_save_types_1;
13810         if (ndr_flags & NDR_SCALARS) {
13811                 NDR_CHECK(ndr_pull_align(ndr, 4));
13812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13813                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
13814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
13816                 if (_ptr_types) {
13817                         NDR_PULL_ALLOC(ndr, r->types);
13818                 } else {
13819                         r->types = NULL;
13820                 }
13821         }
13822         if (ndr_flags & NDR_BUFFERS) {
13823                 if (r->types) {
13824                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
13825                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
13827                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
13828                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
13829                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13830                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13831                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13832                         }
13833                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13834                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13835                         }
13836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
13837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
13838                 }
13839                 if (r->types) {
13840                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
13841                 }
13842         }
13843         return NDR_ERR_SUCCESS;
13844 }
13845
13846 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
13847 {
13848         uint32_t cntr_types_1;
13849         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
13850         ndr->depth++;
13851         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13852         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
13853         ndr_print_uint32(ndr, "count", r->count);
13854         ndr_print_ptr(ndr, "types", r->types);
13855         ndr->depth++;
13856         if (r->types) {
13857                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
13858                 ndr->depth++;
13859                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
13860                         char *idx_1=NULL;
13861                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
13862                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
13863                                 free(idx_1);
13864                         }
13865                 }
13866                 ndr->depth--;
13867         }
13868         ndr->depth--;
13869         ndr->depth--;
13870 }
13871
13872 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
13873 {
13874         if (ndr_flags & NDR_SCALARS) {
13875                 NDR_CHECK(ndr_push_align(ndr, 4));
13876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
13878         }
13879         if (ndr_flags & NDR_BUFFERS) {
13880                 if (r->string) {
13881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
13882                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
13883                 }
13884         }
13885         return NDR_ERR_SUCCESS;
13886 }
13887
13888 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
13889 {
13890         uint32_t _ptr_string;
13891         TALLOC_CTX *_mem_save_string_0;
13892         if (ndr_flags & NDR_SCALARS) {
13893                 NDR_CHECK(ndr_pull_align(ndr, 4));
13894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
13896                 if (_ptr_string) {
13897                         NDR_PULL_ALLOC(ndr, r->string);
13898                 } else {
13899                         r->string = NULL;
13900                 }
13901         }
13902         if (ndr_flags & NDR_BUFFERS) {
13903                 if (r->string) {
13904                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
13905                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
13906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
13907                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
13908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
13909                 }
13910                 if (r->string) {
13911                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
13912                 }
13913         }
13914         return NDR_ERR_SUCCESS;
13915 }
13916
13917 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
13918 {
13919         ndr_print_struct(ndr, name, "spoolss_NotifyString");
13920         ndr->depth++;
13921         ndr_print_uint32(ndr, "size", r->size);
13922         ndr_print_ptr(ndr, "string", r->string);
13923         ndr->depth++;
13924         if (r->string) {
13925                 ndr_print_string(ndr, "string", r->string);
13926         }
13927         ndr->depth--;
13928         ndr->depth--;
13929 }
13930
13931 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
13932 {
13933         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13934         return NDR_ERR_SUCCESS;
13935 }
13936
13937 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
13938 {
13939         uint32_t v;
13940         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13941         *r = v;
13942         return NDR_ERR_SUCCESS;
13943 }
13944
13945 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
13946 {
13947         const char *val = NULL;
13948
13949         switch (r) {
13950                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
13951                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
13952                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
13953                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
13954                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
13955         }
13956         ndr_print_enum(ndr, name, "ENUM", val, r);
13957 }
13958
13959 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
13960 {
13961         if (ndr_flags & NDR_SCALARS) {
13962                 int level = ndr_push_get_switch_value(ndr, r);
13963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13964                 switch (level) {
13965                         case 1: {
13966                                 uint32_t cntr_integer_0;
13967                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13968                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
13969                                 }
13970                         break; }
13971
13972                         case 2: {
13973                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13974                         break; }
13975
13976                         case 3: {
13977                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
13978                         break; }
13979
13980                         case 4: {
13981                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13982                         break; }
13983
13984                         case 5: {
13985                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13986                         break; }
13987
13988                         default:
13989                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13990                 }
13991         }
13992         if (ndr_flags & NDR_BUFFERS) {
13993                 int level = ndr_push_get_switch_value(ndr, r);
13994                 switch (level) {
13995                         case 1:
13996                         break;
13997
13998                         case 2:
13999                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
14000                         break;
14001
14002                         case 3:
14003                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
14004                         break;
14005
14006                         case 4:
14007                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
14008                         break;
14009
14010                         case 5:
14011                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
14012                         break;
14013
14014                         default:
14015                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14016                 }
14017         }
14018         return NDR_ERR_SUCCESS;
14019 }
14020
14021 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
14022 {
14023         int level;
14024         uint32_t _level;
14025         level = ndr_pull_get_switch_value(ndr, r);
14026         if (ndr_flags & NDR_SCALARS) {
14027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14028                 if (_level != level) {
14029                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14030                 }
14031                 switch (level) {
14032                         case 1: {
14033                                 uint32_t cntr_integer_0;
14034                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
14035                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
14036                                 }
14037                         break; }
14038
14039                         case 2: {
14040                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
14041                         break; }
14042
14043                         case 3: {
14044                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
14045                         break; }
14046
14047                         case 4: {
14048                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
14049                         break; }
14050
14051                         case 5: {
14052                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
14053                         break; }
14054
14055                         default:
14056                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14057                 }
14058         }
14059         if (ndr_flags & NDR_BUFFERS) {
14060                 switch (level) {
14061                         case 1:
14062                         break;
14063
14064                         case 2:
14065                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
14066                         break;
14067
14068                         case 3:
14069                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
14070                         break;
14071
14072                         case 4:
14073                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
14074                         break;
14075
14076                         case 5:
14077                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
14078                         break;
14079
14080                         default:
14081                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14082                 }
14083         }
14084         return NDR_ERR_SUCCESS;
14085 }
14086
14087 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
14088 {
14089         int level;
14090         uint32_t cntr_integer_0;
14091         level = ndr_print_get_switch_value(ndr, r);
14092         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
14093         switch (level) {
14094                 case 1:
14095                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
14096                         ndr->depth++;
14097                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
14098                                 char *idx_0=NULL;
14099                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
14100                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
14101                                         free(idx_0);
14102                                 }
14103                         }
14104                         ndr->depth--;
14105                 break;
14106
14107                 case 2:
14108                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
14109                 break;
14110
14111                 case 3:
14112                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
14113                 break;
14114
14115                 case 4:
14116                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
14117                 break;
14118
14119                 case 5:
14120                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
14121                 break;
14122
14123                 default:
14124                         ndr_print_bad_level(ndr, name, level);
14125         }
14126 }
14127
14128 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
14129 {
14130         if (ndr_flags & NDR_SCALARS) {
14131                 NDR_CHECK(ndr_push_align(ndr, 4));
14132                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
14133                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
14134                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
14135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
14136                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
14137                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
14138         }
14139         if (ndr_flags & NDR_BUFFERS) {
14140                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
14141         }
14142         return NDR_ERR_SUCCESS;
14143 }
14144
14145 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
14146 {
14147         if (ndr_flags & NDR_SCALARS) {
14148                 NDR_CHECK(ndr_pull_align(ndr, 4));
14149                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
14150                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
14151                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
14152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
14153                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
14154                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
14155         }
14156         if (ndr_flags & NDR_BUFFERS) {
14157                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
14158         }
14159         return NDR_ERR_SUCCESS;
14160 }
14161
14162 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
14163 {
14164         ndr_print_struct(ndr, name, "spoolss_Notify");
14165         ndr->depth++;
14166         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
14167         ndr_print_spoolss_Field(ndr, "field", r->field);
14168         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
14169         ndr_print_uint32(ndr, "job_id", r->job_id);
14170         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
14171         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
14172         ndr->depth--;
14173 }
14174
14175 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
14176 {
14177         uint32_t cntr_notifies_0;
14178         if (ndr_flags & NDR_SCALARS) {
14179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
14180                 NDR_CHECK(ndr_push_align(ndr, 4));
14181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
14183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
14184                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
14185                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
14186                 }
14187         }
14188         if (ndr_flags & NDR_BUFFERS) {
14189                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
14190                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
14191                 }
14192         }
14193         return NDR_ERR_SUCCESS;
14194 }
14195
14196 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
14197 {
14198         uint32_t cntr_notifies_0;
14199         TALLOC_CTX *_mem_save_notifies_0;
14200         if (ndr_flags & NDR_SCALARS) {
14201                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
14202                 NDR_CHECK(ndr_pull_align(ndr, 4));
14203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
14205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
14206                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
14207                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14208                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
14209                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
14210                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
14211                 }
14212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
14213                 if (r->notifies) {
14214                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
14215                 }
14216         }
14217         if (ndr_flags & NDR_BUFFERS) {
14218                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14219                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
14220                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
14221                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
14222                 }
14223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
14224         }
14225         return NDR_ERR_SUCCESS;
14226 }
14227
14228 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
14229 {
14230         uint32_t cntr_notifies_0;
14231         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
14232         ndr->depth++;
14233         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
14234         ndr_print_uint32(ndr, "flags", r->flags);
14235         ndr_print_uint32(ndr, "count", r->count);
14236         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
14237         ndr->depth++;
14238         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
14239                 char *idx_0=NULL;
14240                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
14241                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
14242                         free(idx_0);
14243                 }
14244         }
14245         ndr->depth--;
14246         ndr->depth--;
14247 }
14248
14249 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
14250 {
14251         if (ndr_flags & NDR_SCALARS) {
14252                 int level = ndr_push_get_switch_value(ndr, r);
14253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14254                 switch (level) {
14255                         case 0: {
14256                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
14257                         break; }
14258
14259                         default:
14260                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14261                 }
14262         }
14263         if (ndr_flags & NDR_BUFFERS) {
14264                 int level = ndr_push_get_switch_value(ndr, r);
14265                 switch (level) {
14266                         case 0:
14267                                 if (r->info0) {
14268                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
14269                                 }
14270                         break;
14271
14272                         default:
14273                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14274                 }
14275         }
14276         return NDR_ERR_SUCCESS;
14277 }
14278
14279 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
14280 {
14281         int level;
14282         uint32_t _level;
14283         TALLOC_CTX *_mem_save_info0_0;
14284         level = ndr_pull_get_switch_value(ndr, r);
14285         if (ndr_flags & NDR_SCALARS) {
14286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14287                 if (_level != level) {
14288                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14289                 }
14290                 switch (level) {
14291                         case 0: {
14292                                 uint32_t _ptr_info0;
14293                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
14294                                 if (_ptr_info0) {
14295                                         NDR_PULL_ALLOC(ndr, r->info0);
14296                                 } else {
14297                                         r->info0 = NULL;
14298                                 }
14299                         break; }
14300
14301                         default:
14302                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14303                 }
14304         }
14305         if (ndr_flags & NDR_BUFFERS) {
14306                 switch (level) {
14307                         case 0:
14308                                 if (r->info0) {
14309                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
14310                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
14311                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
14312                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
14313                                 }
14314                         break;
14315
14316                         default:
14317                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14318                 }
14319         }
14320         return NDR_ERR_SUCCESS;
14321 }
14322
14323 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
14324 {
14325         int level;
14326         level = ndr_print_get_switch_value(ndr, r);
14327         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
14328         switch (level) {
14329                 case 0:
14330                         ndr_print_ptr(ndr, "info0", r->info0);
14331                         ndr->depth++;
14332                         if (r->info0) {
14333                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
14334                         }
14335                         ndr->depth--;
14336                 break;
14337
14338                 default:
14339                         ndr_print_bad_level(ndr, name, level);
14340         }
14341 }
14342
14343 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14344 {
14345         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14346         return NDR_ERR_SUCCESS;
14347 }
14348
14349 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14350 {
14351         uint32_t v;
14352         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14353         *r = v;
14354         return NDR_ERR_SUCCESS;
14355 }
14356
14357 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14358 {
14359         ndr_print_uint32(ndr, name, r);
14360         ndr->depth++;
14361         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
14362         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
14363         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
14364         ndr->depth--;
14365 }
14366
14367 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
14368 {
14369         if (ndr_flags & NDR_SCALARS) {
14370                 NDR_CHECK(ndr_push_align(ndr, 4));
14371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
14372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
14373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
14374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14375                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
14376                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
14377                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
14378         }
14379         if (ndr_flags & NDR_BUFFERS) {
14380                 if (r->client) {
14381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14384                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14385                 }
14386                 if (r->user) {
14387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14390                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14391                 }
14392         }
14393         return NDR_ERR_SUCCESS;
14394 }
14395
14396 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
14397 {
14398         uint32_t _ptr_client;
14399         TALLOC_CTX *_mem_save_client_0;
14400         uint32_t _ptr_user;
14401         TALLOC_CTX *_mem_save_user_0;
14402         if (ndr_flags & NDR_SCALARS) {
14403                 NDR_CHECK(ndr_pull_align(ndr, 4));
14404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14406                 if (_ptr_client) {
14407                         NDR_PULL_ALLOC(ndr, r->client);
14408                 } else {
14409                         r->client = NULL;
14410                 }
14411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14412                 if (_ptr_user) {
14413                         NDR_PULL_ALLOC(ndr, r->user);
14414                 } else {
14415                         r->user = NULL;
14416                 }
14417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14418                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
14419                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
14420                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
14421         }
14422         if (ndr_flags & NDR_BUFFERS) {
14423                 if (r->client) {
14424                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14425                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
14426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
14427                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
14428                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
14429                                 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));
14430                         }
14431                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
14432                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
14433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14434                 }
14435                 if (r->user) {
14436                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14437                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
14438                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
14439                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
14440                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
14441                                 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));
14442                         }
14443                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
14444                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
14445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14446                 }
14447         }
14448         return NDR_ERR_SUCCESS;
14449 }
14450
14451 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
14452 {
14453         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
14454         ndr->depth++;
14455         ndr_print_uint32(ndr, "size", r->size);
14456         ndr_print_ptr(ndr, "client", r->client);
14457         ndr->depth++;
14458         if (r->client) {
14459                 ndr_print_string(ndr, "client", r->client);
14460         }
14461         ndr->depth--;
14462         ndr_print_ptr(ndr, "user", r->user);
14463         ndr->depth++;
14464         if (r->user) {
14465                 ndr_print_string(ndr, "user", r->user);
14466         }
14467         ndr->depth--;
14468         ndr_print_uint32(ndr, "build", r->build);
14469         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
14470         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
14471         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
14472         ndr->depth--;
14473 }
14474
14475 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
14476 {
14477         if (ndr_flags & NDR_SCALARS) {
14478                 NDR_CHECK(ndr_push_align(ndr, 4));
14479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
14480         }
14481         if (ndr_flags & NDR_BUFFERS) {
14482         }
14483         return NDR_ERR_SUCCESS;
14484 }
14485
14486 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
14487 {
14488         if (ndr_flags & NDR_SCALARS) {
14489                 NDR_CHECK(ndr_pull_align(ndr, 4));
14490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
14491         }
14492         if (ndr_flags & NDR_BUFFERS) {
14493         }
14494         return NDR_ERR_SUCCESS;
14495 }
14496
14497 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
14498 {
14499         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
14500         ndr->depth++;
14501         ndr_print_uint32(ndr, "not_used", r->not_used);
14502         ndr->depth--;
14503 }
14504
14505 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
14506 {
14507         if (ndr_flags & NDR_SCALARS) {
14508                 NDR_CHECK(ndr_push_align(ndr, 4));
14509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
14510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
14511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
14512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
14513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
14514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14515                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
14516                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
14517                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
14518                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
14519         }
14520         if (ndr_flags & NDR_BUFFERS) {
14521                 if (r->client) {
14522                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14523                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14525                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14526                 }
14527                 if (r->user) {
14528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14529                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14530                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14531                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14532                 }
14533         }
14534         return NDR_ERR_SUCCESS;
14535 }
14536
14537 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
14538 {
14539         uint32_t _ptr_client;
14540         TALLOC_CTX *_mem_save_client_0;
14541         uint32_t _ptr_user;
14542         TALLOC_CTX *_mem_save_user_0;
14543         if (ndr_flags & NDR_SCALARS) {
14544                 NDR_CHECK(ndr_pull_align(ndr, 4));
14545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
14547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
14548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14549                 if (_ptr_client) {
14550                         NDR_PULL_ALLOC(ndr, r->client);
14551                 } else {
14552                         r->client = NULL;
14553                 }
14554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14555                 if (_ptr_user) {
14556                         NDR_PULL_ALLOC(ndr, r->user);
14557                 } else {
14558                         r->user = NULL;
14559                 }
14560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14561                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
14562                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
14563                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
14564                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
14565         }
14566         if (ndr_flags & NDR_BUFFERS) {
14567                 if (r->client) {
14568                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14569                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
14570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
14571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
14572                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
14573                                 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));
14574                         }
14575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
14576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
14577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14578                 }
14579                 if (r->user) {
14580                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14581                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
14582                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
14583                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
14584                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
14585                                 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));
14586                         }
14587                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
14588                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
14589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14590                 }
14591         }
14592         return NDR_ERR_SUCCESS;
14593 }
14594
14595 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
14596 {
14597         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
14598         ndr->depth++;
14599         ndr_print_uint32(ndr, "size", r->size);
14600         ndr_print_uint32(ndr, "flags", r->flags);
14601         ndr_print_uint32(ndr, "size2", r->size2);
14602         ndr_print_ptr(ndr, "client", r->client);
14603         ndr->depth++;
14604         if (r->client) {
14605                 ndr_print_string(ndr, "client", r->client);
14606         }
14607         ndr->depth--;
14608         ndr_print_ptr(ndr, "user", r->user);
14609         ndr->depth++;
14610         if (r->user) {
14611                 ndr_print_string(ndr, "user", r->user);
14612         }
14613         ndr->depth--;
14614         ndr_print_uint32(ndr, "build", r->build);
14615         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
14616         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
14617         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
14618         ndr_print_udlong(ndr, "reserved", r->reserved);
14619         ndr->depth--;
14620 }
14621
14622 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
14623 {
14624         if (ndr_flags & NDR_SCALARS) {
14625                 int level = ndr_push_get_switch_value(ndr, r);
14626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14627                 switch (level) {
14628                         case 1: {
14629                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
14630                         break; }
14631
14632                         case 2: {
14633                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
14634                         break; }
14635
14636                         case 3: {
14637                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
14638                         break; }
14639
14640                         default:
14641                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14642                 }
14643         }
14644         if (ndr_flags & NDR_BUFFERS) {
14645                 int level = ndr_push_get_switch_value(ndr, r);
14646                 switch (level) {
14647                         case 1:
14648                                 if (r->level1) {
14649                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14650                                 }
14651                         break;
14652
14653                         case 2:
14654                                 if (r->level2) {
14655                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14656                                 }
14657                         break;
14658
14659                         case 3:
14660                                 if (r->level3) {
14661                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14662                                 }
14663                         break;
14664
14665                         default:
14666                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14667                 }
14668         }
14669         return NDR_ERR_SUCCESS;
14670 }
14671
14672 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
14673 {
14674         int level;
14675         uint32_t _level;
14676         TALLOC_CTX *_mem_save_level1_0;
14677         TALLOC_CTX *_mem_save_level2_0;
14678         TALLOC_CTX *_mem_save_level3_0;
14679         level = ndr_pull_get_switch_value(ndr, r);
14680         if (ndr_flags & NDR_SCALARS) {
14681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14682                 if (_level != level) {
14683                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14684                 }
14685                 switch (level) {
14686                         case 1: {
14687                                 uint32_t _ptr_level1;
14688                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
14689                                 if (_ptr_level1) {
14690                                         NDR_PULL_ALLOC(ndr, r->level1);
14691                                 } else {
14692                                         r->level1 = NULL;
14693                                 }
14694                         break; }
14695
14696                         case 2: {
14697                                 uint32_t _ptr_level2;
14698                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
14699                                 if (_ptr_level2) {
14700                                         NDR_PULL_ALLOC(ndr, r->level2);
14701                                 } else {
14702                                         r->level2 = NULL;
14703                                 }
14704                         break; }
14705
14706                         case 3: {
14707                                 uint32_t _ptr_level3;
14708                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
14709                                 if (_ptr_level3) {
14710                                         NDR_PULL_ALLOC(ndr, r->level3);
14711                                 } else {
14712                                         r->level3 = NULL;
14713                                 }
14714                         break; }
14715
14716                         default:
14717                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14718                 }
14719         }
14720         if (ndr_flags & NDR_BUFFERS) {
14721                 switch (level) {
14722                         case 1:
14723                                 if (r->level1) {
14724                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14725                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
14726                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14727                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
14728                                 }
14729                         break;
14730
14731                         case 2:
14732                                 if (r->level2) {
14733                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
14734                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
14735                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14736                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
14737                                 }
14738                         break;
14739
14740                         case 3:
14741                                 if (r->level3) {
14742                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
14743                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
14744                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14745                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
14746                                 }
14747                         break;
14748
14749                         default:
14750                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14751                 }
14752         }
14753         return NDR_ERR_SUCCESS;
14754 }
14755
14756 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
14757 {
14758         int level;
14759         level = ndr_print_get_switch_value(ndr, r);
14760         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
14761         switch (level) {
14762                 case 1:
14763                         ndr_print_ptr(ndr, "level1", r->level1);
14764                         ndr->depth++;
14765                         if (r->level1) {
14766                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
14767                         }
14768                         ndr->depth--;
14769                 break;
14770
14771                 case 2:
14772                         ndr_print_ptr(ndr, "level2", r->level2);
14773                         ndr->depth++;
14774                         if (r->level2) {
14775                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
14776                         }
14777                         ndr->depth--;
14778                 break;
14779
14780                 case 3:
14781                         ndr_print_ptr(ndr, "level3", r->level3);
14782                         ndr->depth++;
14783                         if (r->level3) {
14784                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
14785                         }
14786                         ndr->depth--;
14787                 break;
14788
14789                 default:
14790                         ndr_print_bad_level(ndr, name, level);
14791         }
14792 }
14793
14794 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
14795 {
14796         if (ndr_flags & NDR_SCALARS) {
14797                 NDR_CHECK(ndr_push_align(ndr, 4));
14798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
14799                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
14800                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14801         }
14802         if (ndr_flags & NDR_BUFFERS) {
14803                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14804         }
14805         return NDR_ERR_SUCCESS;
14806 }
14807
14808 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
14809 {
14810         if (ndr_flags & NDR_SCALARS) {
14811                 NDR_CHECK(ndr_pull_align(ndr, 4));
14812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
14813                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
14814                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14815         }
14816         if (ndr_flags & NDR_BUFFERS) {
14817                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14818         }
14819         return NDR_ERR_SUCCESS;
14820 }
14821
14822 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
14823 {
14824         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
14825         ndr->depth++;
14826         ndr_print_uint32(ndr, "level", r->level);
14827         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
14828         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
14829         ndr->depth--;
14830 }
14831
14832 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14833 {
14834         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14835         return NDR_ERR_SUCCESS;
14836 }
14837
14838 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14839 {
14840         uint32_t v;
14841         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14842         *r = v;
14843         return NDR_ERR_SUCCESS;
14844 }
14845
14846 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
14847 {
14848         ndr_print_uint32(ndr, name, r);
14849         ndr->depth++;
14850         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
14851         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
14852         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
14853         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
14854         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
14855         ndr->depth--;
14856 }
14857
14858 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14859 {
14860         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14861         return NDR_ERR_SUCCESS;
14862 }
14863
14864 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14865 {
14866         uint32_t v;
14867         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14868         *r = v;
14869         return NDR_ERR_SUCCESS;
14870 }
14871
14872 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14873 {
14874         ndr_print_uint32(ndr, name, r);
14875         ndr->depth++;
14876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
14877         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
14878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
14879         ndr->depth--;
14880 }
14881
14882 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
14883 {
14884         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14885         return NDR_ERR_SUCCESS;
14886 }
14887
14888 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
14889 {
14890         uint32_t v;
14891         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14892         *r = v;
14893         return NDR_ERR_SUCCESS;
14894 }
14895
14896 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
14897 {
14898         const char *val = NULL;
14899
14900         switch (r) {
14901                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
14902                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
14903         }
14904         ndr_print_enum(ndr, name, "ENUM", val, r);
14905 }
14906
14907 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
14908 {
14909         if (ndr_flags & NDR_SCALARS) {
14910                 NDR_CHECK(ndr_push_align(ndr, 4));
14911                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
14913                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14916                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14917                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14919                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14920                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14921                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14922                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14926         }
14927         if (ndr_flags & NDR_BUFFERS) {
14928         }
14929         return NDR_ERR_SUCCESS;
14930 }
14931
14932 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
14933 {
14934         if (ndr_flags & NDR_SCALARS) {
14935                 NDR_CHECK(ndr_pull_align(ndr, 4));
14936                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14938                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14940                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14941                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14942                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14944                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14945                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14946                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14947                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14951         }
14952         if (ndr_flags & NDR_BUFFERS) {
14953         }
14954         return NDR_ERR_SUCCESS;
14955 }
14956
14957 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
14958 {
14959         ndr_print_struct(ndr, name, "spoolss_PortData1");
14960         ndr->depth++;
14961         ndr_print_string(ndr, "portname", r->portname);
14962         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
14963         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14964         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14965         ndr_print_uint32(ndr, "reserved", r->reserved);
14966         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14967         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14968         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14969         ndr_print_string(ndr, "queue", r->queue);
14970         ndr_print_string(ndr, "ip_address", r->ip_address);
14971         ndr_print_string(ndr, "hardware_address", r->hardware_address);
14972         ndr_print_string(ndr, "device_type", r->device_type);
14973         ndr_print_uint32(ndr, "port_number", r->port_number);
14974         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14975         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14976         ndr->depth--;
14977 }
14978
14979 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
14980 {
14981         if (ndr_flags & NDR_SCALARS) {
14982                 NDR_CHECK(ndr_push_align(ndr, 4));
14983                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
14985                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14988                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14989                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14991                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14992                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
14997         }
14998         if (ndr_flags & NDR_BUFFERS) {
14999         }
15000         return NDR_ERR_SUCCESS;
15001 }
15002
15003 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
15004 {
15005         if (ndr_flags & NDR_SCALARS) {
15006                 NDR_CHECK(ndr_pull_align(ndr, 4));
15007                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
15008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
15009                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
15010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
15011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15012                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
15013                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
15014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
15015                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
15016                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
15017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
15018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
15019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
15020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
15021         }
15022         if (ndr_flags & NDR_BUFFERS) {
15023         }
15024         return NDR_ERR_SUCCESS;
15025 }
15026
15027 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
15028 {
15029         ndr_print_struct(ndr, name, "spoolss_PortData2");
15030         ndr->depth++;
15031         ndr_print_string(ndr, "portname", r->portname);
15032         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
15033         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
15034         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
15035         ndr_print_uint32(ndr, "reserved", r->reserved);
15036         ndr_print_string(ndr, "hostaddress", r->hostaddress);
15037         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
15038         ndr_print_uint32(ndr, "dblspool", r->dblspool);
15039         ndr_print_string(ndr, "queue", r->queue);
15040         ndr_print_string(ndr, "device_type", r->device_type);
15041         ndr_print_uint32(ndr, "port_number", r->port_number);
15042         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
15043         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
15044         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
15045         ndr->depth--;
15046 }
15047
15048 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
15049 {
15050         if (ndr_flags & NDR_SCALARS) {
15051                 NDR_CHECK(ndr_push_align(ndr, 4));
15052                 {
15053                         uint32_t _flags_save_string = ndr->flags;
15054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15055                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
15056                         ndr->flags = _flags_save_string;
15057                 }
15058         }
15059         if (ndr_flags & NDR_BUFFERS) {
15060         }
15061         return NDR_ERR_SUCCESS;
15062 }
15063
15064 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
15065 {
15066         if (ndr_flags & NDR_SCALARS) {
15067                 NDR_CHECK(ndr_pull_align(ndr, 4));
15068                 {
15069                         uint32_t _flags_save_string = ndr->flags;
15070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15071                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
15072                         ndr->flags = _flags_save_string;
15073                 }
15074         }
15075         if (ndr_flags & NDR_BUFFERS) {
15076         }
15077         return NDR_ERR_SUCCESS;
15078 }
15079
15080 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
15081 {
15082         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
15083         ndr->depth++;
15084         ndr_print_string(ndr, "dll_name", r->dll_name);
15085         ndr->depth--;
15086 }
15087
15088 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15089 {
15090         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15091         return NDR_ERR_SUCCESS;
15092 }
15093
15094 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15095 {
15096         uint32_t v;
15097         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15098         *r = v;
15099         return NDR_ERR_SUCCESS;
15100 }
15101
15102 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
15103 {
15104         ndr_print_uint32(ndr, name, r);
15105         ndr->depth++;
15106         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
15107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
15108         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
15109         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
15110         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
15111         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
15112         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
15113         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
15114         ndr->depth--;
15115 }
15116
15117 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
15118 {
15119         if (flags & NDR_IN) {
15120                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
15121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15122                 if (r->in.server) {
15123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15127                 }
15128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15130                 if (r->in.buffer) {
15131                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15132                 }
15133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15134         }
15135         if (flags & NDR_OUT) {
15136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15137                 if (r->out.info) {
15138                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15139                 }
15140                 if (r->out.needed == NULL) {
15141                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15142                 }
15143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15144                 if (r->out.count == NULL) {
15145                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15146                 }
15147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15148                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15149         }
15150         return NDR_ERR_SUCCESS;
15151 }
15152
15153 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
15154 {
15155         uint32_t _ptr_server;
15156         uint32_t _ptr_buffer;
15157         uint32_t _ptr_info;
15158         TALLOC_CTX *_mem_save_server_0;
15159         TALLOC_CTX *_mem_save_buffer_0;
15160         TALLOC_CTX *_mem_save_info_0;
15161         TALLOC_CTX *_mem_save_needed_0;
15162         TALLOC_CTX *_mem_save_count_0;
15163         if (flags & NDR_IN) {
15164                 ZERO_STRUCT(r->out);
15165
15166                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
15167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15168                 if (_ptr_server) {
15169                         NDR_PULL_ALLOC(ndr, r->in.server);
15170                 } else {
15171                         r->in.server = NULL;
15172                 }
15173                 if (r->in.server) {
15174                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15175                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15178                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15179                                 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));
15180                         }
15181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15184                 }
15185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15187                 if (_ptr_buffer) {
15188                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15189                 } else {
15190                         r->in.buffer = NULL;
15191                 }
15192                 if (r->in.buffer) {
15193                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15194                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15195                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15197                 }
15198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15199                 NDR_PULL_ALLOC(ndr, r->out.needed);
15200                 ZERO_STRUCTP(r->out.needed);
15201                 NDR_PULL_ALLOC(ndr, r->out.count);
15202                 ZERO_STRUCTP(r->out.count);
15203         }
15204         if (flags & NDR_OUT) {
15205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15206                 if (_ptr_info) {
15207                         NDR_PULL_ALLOC(ndr, r->out.info);
15208                 } else {
15209                         r->out.info = NULL;
15210                 }
15211                 if (r->out.info) {
15212                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15213                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15214                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15216                 }
15217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15218                         NDR_PULL_ALLOC(ndr, r->out.needed);
15219                 }
15220                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15221                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15224                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15225                         NDR_PULL_ALLOC(ndr, r->out.count);
15226                 }
15227                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15228                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15231                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15232         }
15233         return NDR_ERR_SUCCESS;
15234 }
15235
15236 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
15237 {
15238         uint32_t cntr_info_0;
15239         if (flags & NDR_IN) {
15240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15242         }
15243         if (flags & NDR_OUT) {
15244                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15245                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15246                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15247                 }
15248                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15249                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15250                 }
15251         }
15252         return NDR_ERR_SUCCESS;
15253 }
15254
15255 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
15256 {
15257         uint32_t cntr_info_0;
15258         TALLOC_CTX *_mem_save_info_0;
15259         if (flags & NDR_IN) {
15260                 ZERO_STRUCT(r->out);
15261
15262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15264         }
15265         if (flags & NDR_OUT) {
15266                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15267                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15268                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15269                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15270                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15271                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15272                 }
15273                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15274                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15275                 }
15276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15277         }
15278         return NDR_ERR_SUCCESS;
15279 }
15280
15281 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
15282 {
15283         uint32_t cntr_info_1;
15284         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
15285         ndr->depth++;
15286         if (flags & NDR_SET_VALUES) {
15287                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15288         }
15289         if (flags & NDR_IN) {
15290                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
15291                 ndr->depth++;
15292                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
15293                 ndr_print_ptr(ndr, "server", r->in.server);
15294                 ndr->depth++;
15295                 if (r->in.server) {
15296                         ndr_print_string(ndr, "server", r->in.server);
15297                 }
15298                 ndr->depth--;
15299                 ndr_print_uint32(ndr, "level", r->in.level);
15300                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15301                 ndr->depth++;
15302                 if (r->in.buffer) {
15303                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15304                 }
15305                 ndr->depth--;
15306                 ndr_print_uint32(ndr, "offered", r->in.offered);
15307                 ndr->depth--;
15308         }
15309         if (flags & NDR_OUT) {
15310                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
15311                 ndr->depth++;
15312                 ndr_print_ptr(ndr, "count", r->out.count);
15313                 ndr->depth++;
15314                 ndr_print_uint32(ndr, "count", *r->out.count);
15315                 ndr->depth--;
15316                 ndr_print_ptr(ndr, "info", r->out.info);
15317                 ndr->depth++;
15318                 if (r->out.info) {
15319                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15320                         ndr->depth++;
15321                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15322                                 char *idx_1=NULL;
15323                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15324                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15325                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
15326                                         free(idx_1);
15327                                 }
15328                         }
15329                         ndr->depth--;
15330                 }
15331                 ndr->depth--;
15332                 ndr_print_ptr(ndr, "needed", r->out.needed);
15333                 ndr->depth++;
15334                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15335                 ndr->depth--;
15336                 ndr_print_WERROR(ndr, "result", r->out.result);
15337                 ndr->depth--;
15338         }
15339         ndr->depth--;
15340 }
15341
15342 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
15343 {
15344         if (flags & NDR_IN) {
15345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
15346                 if (r->in.printername) {
15347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
15348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
15350                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15351                 }
15352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
15353                 if (r->in.datatype) {
15354                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
15355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
15357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15358                 }
15359                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15360                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
15361         }
15362         if (flags & NDR_OUT) {
15363                 if (r->out.handle == NULL) {
15364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15365                 }
15366                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15367                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15368         }
15369         return NDR_ERR_SUCCESS;
15370 }
15371
15372 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
15373 {
15374         uint32_t _ptr_printername;
15375         uint32_t _ptr_datatype;
15376         TALLOC_CTX *_mem_save_printername_0;
15377         TALLOC_CTX *_mem_save_datatype_0;
15378         TALLOC_CTX *_mem_save_handle_0;
15379         if (flags & NDR_IN) {
15380                 ZERO_STRUCT(r->out);
15381
15382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
15383                 if (_ptr_printername) {
15384                         NDR_PULL_ALLOC(ndr, r->in.printername);
15385                 } else {
15386                         r->in.printername = NULL;
15387                 }
15388                 if (r->in.printername) {
15389                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
15390                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
15391                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
15392                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
15393                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
15394                                 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));
15395                         }
15396                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
15397                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
15398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
15399                 }
15400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15401                 if (_ptr_datatype) {
15402                         NDR_PULL_ALLOC(ndr, r->in.datatype);
15403                 } else {
15404                         r->in.datatype = NULL;
15405                 }
15406                 if (r->in.datatype) {
15407                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15408                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
15409                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
15410                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
15411                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
15412                                 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));
15413                         }
15414                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
15415                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
15416                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15417                 }
15418                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15419                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
15420                 NDR_PULL_ALLOC(ndr, r->out.handle);
15421                 ZERO_STRUCTP(r->out.handle);
15422         }
15423         if (flags & NDR_OUT) {
15424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15425                         NDR_PULL_ALLOC(ndr, r->out.handle);
15426                 }
15427                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15428                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
15429                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15431                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15432         }
15433         return NDR_ERR_SUCCESS;
15434 }
15435
15436 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
15437 {
15438         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
15439         ndr->depth++;
15440         if (flags & NDR_SET_VALUES) {
15441                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15442         }
15443         if (flags & NDR_IN) {
15444                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
15445                 ndr->depth++;
15446                 ndr_print_ptr(ndr, "printername", r->in.printername);
15447                 ndr->depth++;
15448                 if (r->in.printername) {
15449                         ndr_print_string(ndr, "printername", r->in.printername);
15450                 }
15451                 ndr->depth--;
15452                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
15453                 ndr->depth++;
15454                 if (r->in.datatype) {
15455                         ndr_print_string(ndr, "datatype", r->in.datatype);
15456                 }
15457                 ndr->depth--;
15458                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
15459                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
15460                 ndr->depth--;
15461         }
15462         if (flags & NDR_OUT) {
15463                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
15464                 ndr->depth++;
15465                 ndr_print_ptr(ndr, "handle", r->out.handle);
15466                 ndr->depth++;
15467                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
15468                 ndr->depth--;
15469                 ndr_print_WERROR(ndr, "result", r->out.result);
15470                 ndr->depth--;
15471         }
15472         ndr->depth--;
15473 }
15474
15475 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
15476 {
15477         if (flags & NDR_IN) {
15478                 if (r->in.handle == NULL) {
15479                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15480                 }
15481                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
15483                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
15484                 if (r->in.ctr) {
15485                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
15486                 }
15487                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
15488         }
15489         if (flags & NDR_OUT) {
15490                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15491         }
15492         return NDR_ERR_SUCCESS;
15493 }
15494
15495 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
15496 {
15497         uint32_t _ptr_ctr;
15498         TALLOC_CTX *_mem_save_handle_0;
15499         TALLOC_CTX *_mem_save_ctr_0;
15500         if (flags & NDR_IN) {
15501                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15502                         NDR_PULL_ALLOC(ndr, r->in.handle);
15503                 }
15504                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15505                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15506                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
15509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
15510                 if (_ptr_ctr) {
15511                         NDR_PULL_ALLOC(ndr, r->in.ctr);
15512                 } else {
15513                         r->in.ctr = NULL;
15514                 }
15515                 if (r->in.ctr) {
15516                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15517                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
15518                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
15519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
15520                 }
15521                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
15522         }
15523         if (flags & NDR_OUT) {
15524                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15525         }
15526         return NDR_ERR_SUCCESS;
15527 }
15528
15529 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
15530 {
15531         ndr_print_struct(ndr, name, "spoolss_SetJob");
15532         ndr->depth++;
15533         if (flags & NDR_SET_VALUES) {
15534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15535         }
15536         if (flags & NDR_IN) {
15537                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
15538                 ndr->depth++;
15539                 ndr_print_ptr(ndr, "handle", r->in.handle);
15540                 ndr->depth++;
15541                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15542                 ndr->depth--;
15543                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15544                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
15545                 ndr->depth++;
15546                 if (r->in.ctr) {
15547                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
15548                 }
15549                 ndr->depth--;
15550                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
15551                 ndr->depth--;
15552         }
15553         if (flags & NDR_OUT) {
15554                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
15555                 ndr->depth++;
15556                 ndr_print_WERROR(ndr, "result", r->out.result);
15557                 ndr->depth--;
15558         }
15559         ndr->depth--;
15560 }
15561
15562 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
15563 {
15564         if (flags & NDR_IN) {
15565                 if (r->in.handle == NULL) {
15566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15567                 }
15568                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
15570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15572                 if (r->in.buffer) {
15573                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15574                 }
15575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15576         }
15577         if (flags & NDR_OUT) {
15578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15579                 if (r->out.info) {
15580                         {
15581                                 struct ndr_push *_ndr_info;
15582                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15583                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15584                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15585                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15586                         }
15587                 }
15588                 if (r->out.needed == NULL) {
15589                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15590                 }
15591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15592                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15593         }
15594         return NDR_ERR_SUCCESS;
15595 }
15596
15597 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
15598 {
15599         uint32_t _ptr_buffer;
15600         uint32_t _ptr_info;
15601         TALLOC_CTX *_mem_save_handle_0;
15602         TALLOC_CTX *_mem_save_buffer_0;
15603         TALLOC_CTX *_mem_save_info_0;
15604         TALLOC_CTX *_mem_save_needed_0;
15605         if (flags & NDR_IN) {
15606                 ZERO_STRUCT(r->out);
15607
15608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15609                         NDR_PULL_ALLOC(ndr, r->in.handle);
15610                 }
15611                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15612                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15613                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
15616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15618                 if (_ptr_buffer) {
15619                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15620                 } else {
15621                         r->in.buffer = NULL;
15622                 }
15623                 if (r->in.buffer) {
15624                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15625                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15626                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15628                 }
15629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15630                 NDR_PULL_ALLOC(ndr, r->out.needed);
15631                 ZERO_STRUCTP(r->out.needed);
15632         }
15633         if (flags & NDR_OUT) {
15634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15635                 if (_ptr_info) {
15636                         NDR_PULL_ALLOC(ndr, r->out.info);
15637                 } else {
15638                         r->out.info = NULL;
15639                 }
15640                 if (r->out.info) {
15641                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15642                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15643                         {
15644                                 struct ndr_pull *_ndr_info;
15645                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15646                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15647                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15648                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15649                         }
15650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15651                 }
15652                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15653                         NDR_PULL_ALLOC(ndr, r->out.needed);
15654                 }
15655                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15656                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15660         }
15661         return NDR_ERR_SUCCESS;
15662 }
15663
15664 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
15665 {
15666         ndr_print_struct(ndr, name, "spoolss_GetJob");
15667         ndr->depth++;
15668         if (flags & NDR_SET_VALUES) {
15669                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15670         }
15671         if (flags & NDR_IN) {
15672                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
15673                 ndr->depth++;
15674                 ndr_print_ptr(ndr, "handle", r->in.handle);
15675                 ndr->depth++;
15676                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15677                 ndr->depth--;
15678                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15679                 ndr_print_uint32(ndr, "level", r->in.level);
15680                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15681                 ndr->depth++;
15682                 if (r->in.buffer) {
15683                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15684                 }
15685                 ndr->depth--;
15686                 ndr_print_uint32(ndr, "offered", r->in.offered);
15687                 ndr->depth--;
15688         }
15689         if (flags & NDR_OUT) {
15690                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
15691                 ndr->depth++;
15692                 ndr_print_ptr(ndr, "info", r->out.info);
15693                 ndr->depth++;
15694                 if (r->out.info) {
15695                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15696                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
15697                 }
15698                 ndr->depth--;
15699                 ndr_print_ptr(ndr, "needed", r->out.needed);
15700                 ndr->depth++;
15701                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15702                 ndr->depth--;
15703                 ndr_print_WERROR(ndr, "result", r->out.result);
15704                 ndr->depth--;
15705         }
15706         ndr->depth--;
15707 }
15708
15709 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
15710 {
15711         if (flags & NDR_IN) {
15712                 if (r->in.handle == NULL) {
15713                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15714                 }
15715                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
15717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
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_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
15744 {
15745         uint32_t _ptr_buffer;
15746         uint32_t _ptr_info;
15747         TALLOC_CTX *_mem_save_handle_0;
15748         TALLOC_CTX *_mem_save_buffer_0;
15749         TALLOC_CTX *_mem_save_info_0;
15750         TALLOC_CTX *_mem_save_needed_0;
15751         TALLOC_CTX *_mem_save_count_0;
15752         if (flags & NDR_IN) {
15753                 ZERO_STRUCT(r->out);
15754
15755                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15756                         NDR_PULL_ALLOC(ndr, r->in.handle);
15757                 }
15758                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15759                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15760                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
15763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
15764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15766                 if (_ptr_buffer) {
15767                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15768                 } else {
15769                         r->in.buffer = NULL;
15770                 }
15771                 if (r->in.buffer) {
15772                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15774                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15776                 }
15777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15778                 NDR_PULL_ALLOC(ndr, r->out.needed);
15779                 ZERO_STRUCTP(r->out.needed);
15780                 NDR_PULL_ALLOC(ndr, r->out.count);
15781                 ZERO_STRUCTP(r->out.count);
15782         }
15783         if (flags & NDR_OUT) {
15784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15785                 if (_ptr_info) {
15786                         NDR_PULL_ALLOC(ndr, r->out.info);
15787                 } else {
15788                         r->out.info = NULL;
15789                 }
15790                 if (r->out.info) {
15791                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15792                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15793                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15795                 }
15796                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15797                         NDR_PULL_ALLOC(ndr, r->out.needed);
15798                 }
15799                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15800                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15804                         NDR_PULL_ALLOC(ndr, r->out.count);
15805                 }
15806                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15807                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15810                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15811         }
15812         return NDR_ERR_SUCCESS;
15813 }
15814
15815 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
15816 {
15817         uint32_t cntr_info_0;
15818         if (flags & NDR_IN) {
15819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15821         }
15822         if (flags & NDR_OUT) {
15823                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15824                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15825                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15826                 }
15827                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15828                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15829                 }
15830         }
15831         return NDR_ERR_SUCCESS;
15832 }
15833
15834 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
15835 {
15836         uint32_t cntr_info_0;
15837         TALLOC_CTX *_mem_save_info_0;
15838         if (flags & NDR_IN) {
15839                 ZERO_STRUCT(r->out);
15840
15841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15843         }
15844         if (flags & NDR_OUT) {
15845                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15846                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15848                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15849                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15850                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15851                 }
15852                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15853                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15854                 }
15855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15856         }
15857         return NDR_ERR_SUCCESS;
15858 }
15859
15860 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
15861 {
15862         uint32_t cntr_info_1;
15863         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
15864         ndr->depth++;
15865         if (flags & NDR_SET_VALUES) {
15866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15867         }
15868         if (flags & NDR_IN) {
15869                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
15870                 ndr->depth++;
15871                 ndr_print_ptr(ndr, "handle", r->in.handle);
15872                 ndr->depth++;
15873                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15874                 ndr->depth--;
15875                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
15876                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
15877                 ndr_print_uint32(ndr, "level", r->in.level);
15878                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15879                 ndr->depth++;
15880                 if (r->in.buffer) {
15881                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15882                 }
15883                 ndr->depth--;
15884                 ndr_print_uint32(ndr, "offered", r->in.offered);
15885                 ndr->depth--;
15886         }
15887         if (flags & NDR_OUT) {
15888                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
15889                 ndr->depth++;
15890                 ndr_print_ptr(ndr, "count", r->out.count);
15891                 ndr->depth++;
15892                 ndr_print_uint32(ndr, "count", *r->out.count);
15893                 ndr->depth--;
15894                 ndr_print_ptr(ndr, "info", r->out.info);
15895                 ndr->depth++;
15896                 if (r->out.info) {
15897                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15898                         ndr->depth++;
15899                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15900                                 char *idx_1=NULL;
15901                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15902                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15903                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
15904                                         free(idx_1);
15905                                 }
15906                         }
15907                         ndr->depth--;
15908                 }
15909                 ndr->depth--;
15910                 ndr_print_ptr(ndr, "needed", r->out.needed);
15911                 ndr->depth++;
15912                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15913                 ndr->depth--;
15914                 ndr_print_WERROR(ndr, "result", r->out.result);
15915                 ndr->depth--;
15916         }
15917         ndr->depth--;
15918 }
15919
15920 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
15921 {
15922         if (flags & NDR_IN) {
15923         }
15924         if (flags & NDR_OUT) {
15925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15926         }
15927         return NDR_ERR_SUCCESS;
15928 }
15929
15930 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
15931 {
15932         if (flags & NDR_IN) {
15933         }
15934         if (flags & NDR_OUT) {
15935                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15936         }
15937         return NDR_ERR_SUCCESS;
15938 }
15939
15940 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
15941 {
15942         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
15943         ndr->depth++;
15944         if (flags & NDR_SET_VALUES) {
15945                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15946         }
15947         if (flags & NDR_IN) {
15948                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
15949                 ndr->depth++;
15950                 ndr->depth--;
15951         }
15952         if (flags & NDR_OUT) {
15953                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
15954                 ndr->depth++;
15955                 ndr_print_WERROR(ndr, "result", r->out.result);
15956                 ndr->depth--;
15957         }
15958         ndr->depth--;
15959 }
15960
15961 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
15962 {
15963         if (flags & NDR_IN) {
15964                 if (r->in.handle == NULL) {
15965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15966                 }
15967                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15968         }
15969         if (flags & NDR_OUT) {
15970                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15971         }
15972         return NDR_ERR_SUCCESS;
15973 }
15974
15975 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
15976 {
15977         TALLOC_CTX *_mem_save_handle_0;
15978         if (flags & NDR_IN) {
15979                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15980                         NDR_PULL_ALLOC(ndr, r->in.handle);
15981                 }
15982                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15983                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15984                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15986         }
15987         if (flags & NDR_OUT) {
15988                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15989         }
15990         return NDR_ERR_SUCCESS;
15991 }
15992
15993 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
15994 {
15995         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
15996         ndr->depth++;
15997         if (flags & NDR_SET_VALUES) {
15998                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15999         }
16000         if (flags & NDR_IN) {
16001                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
16002                 ndr->depth++;
16003                 ndr_print_ptr(ndr, "handle", r->in.handle);
16004                 ndr->depth++;
16005                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16006                 ndr->depth--;
16007                 ndr->depth--;
16008         }
16009         if (flags & NDR_OUT) {
16010                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
16011                 ndr->depth++;
16012                 ndr_print_WERROR(ndr, "result", r->out.result);
16013                 ndr->depth--;
16014         }
16015         ndr->depth--;
16016 }
16017
16018 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
16019 {
16020         if (flags & NDR_IN) {
16021                 if (r->in.handle == NULL) {
16022                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16023                 }
16024                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16025                 if (r->in.info_ctr == NULL) {
16026                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16027                 }
16028                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16029                 if (r->in.devmode_ctr == NULL) {
16030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16031                 }
16032                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
16033                 if (r->in.secdesc_ctr == NULL) {
16034                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16035                 }
16036                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
16037                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
16038         }
16039         if (flags & NDR_OUT) {
16040                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16041         }
16042         return NDR_ERR_SUCCESS;
16043 }
16044
16045 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
16046 {
16047         TALLOC_CTX *_mem_save_handle_0;
16048         TALLOC_CTX *_mem_save_info_ctr_0;
16049         TALLOC_CTX *_mem_save_devmode_ctr_0;
16050         TALLOC_CTX *_mem_save_secdesc_ctr_0;
16051         if (flags & NDR_IN) {
16052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16053                         NDR_PULL_ALLOC(ndr, r->in.handle);
16054                 }
16055                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16056                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16057                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16060                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
16061                 }
16062                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16063                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
16064                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16067                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
16068                 }
16069                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16070                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
16071                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
16072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16073                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16074                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
16075                 }
16076                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16077                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
16078                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
16079                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16080                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
16081         }
16082         if (flags & NDR_OUT) {
16083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16084         }
16085         return NDR_ERR_SUCCESS;
16086 }
16087
16088 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
16089 {
16090         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
16091         ndr->depth++;
16092         if (flags & NDR_SET_VALUES) {
16093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16094         }
16095         if (flags & NDR_IN) {
16096                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
16097                 ndr->depth++;
16098                 ndr_print_ptr(ndr, "handle", r->in.handle);
16099                 ndr->depth++;
16100                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16101                 ndr->depth--;
16102                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
16103                 ndr->depth++;
16104                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
16105                 ndr->depth--;
16106                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
16107                 ndr->depth++;
16108                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
16109                 ndr->depth--;
16110                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
16111                 ndr->depth++;
16112                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
16113                 ndr->depth--;
16114                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
16115                 ndr->depth--;
16116         }
16117         if (flags & NDR_OUT) {
16118                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
16119                 ndr->depth++;
16120                 ndr_print_WERROR(ndr, "result", r->out.result);
16121                 ndr->depth--;
16122         }
16123         ndr->depth--;
16124 }
16125
16126 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
16127 {
16128         if (flags & NDR_IN) {
16129                 if (r->in.handle == NULL) {
16130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16131                 }
16132                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16135                 if (r->in.buffer) {
16136                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16137                 }
16138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16139         }
16140         if (flags & NDR_OUT) {
16141                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16142                 if (r->out.info) {
16143                         {
16144                                 struct ndr_push *_ndr_info;
16145                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16146                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16147                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16148                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16149                         }
16150                 }
16151                 if (r->out.needed == NULL) {
16152                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16153                 }
16154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16155                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16156         }
16157         return NDR_ERR_SUCCESS;
16158 }
16159
16160 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
16161 {
16162         uint32_t _ptr_buffer;
16163         uint32_t _ptr_info;
16164         TALLOC_CTX *_mem_save_handle_0;
16165         TALLOC_CTX *_mem_save_buffer_0;
16166         TALLOC_CTX *_mem_save_info_0;
16167         TALLOC_CTX *_mem_save_needed_0;
16168         if (flags & NDR_IN) {
16169                 ZERO_STRUCT(r->out);
16170
16171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16172                         NDR_PULL_ALLOC(ndr, r->in.handle);
16173                 }
16174                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16175                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16176                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16180                 if (_ptr_buffer) {
16181                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16182                 } else {
16183                         r->in.buffer = NULL;
16184                 }
16185                 if (r->in.buffer) {
16186                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16187                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16188                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16189                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16190                 }
16191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16192                 NDR_PULL_ALLOC(ndr, r->out.needed);
16193                 ZERO_STRUCTP(r->out.needed);
16194         }
16195         if (flags & NDR_OUT) {
16196                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16197                 if (_ptr_info) {
16198                         NDR_PULL_ALLOC(ndr, r->out.info);
16199                 } else {
16200                         r->out.info = NULL;
16201                 }
16202                 if (r->out.info) {
16203                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16204                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16205                         {
16206                                 struct ndr_pull *_ndr_info;
16207                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16208                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16209                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16210                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16211                         }
16212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16213                 }
16214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16215                         NDR_PULL_ALLOC(ndr, r->out.needed);
16216                 }
16217                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16222         }
16223         return NDR_ERR_SUCCESS;
16224 }
16225
16226 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
16227 {
16228         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
16229         ndr->depth++;
16230         if (flags & NDR_SET_VALUES) {
16231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16232         }
16233         if (flags & NDR_IN) {
16234                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
16235                 ndr->depth++;
16236                 ndr_print_ptr(ndr, "handle", r->in.handle);
16237                 ndr->depth++;
16238                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16239                 ndr->depth--;
16240                 ndr_print_uint32(ndr, "level", r->in.level);
16241                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16242                 ndr->depth++;
16243                 if (r->in.buffer) {
16244                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16245                 }
16246                 ndr->depth--;
16247                 ndr_print_uint32(ndr, "offered", r->in.offered);
16248                 ndr->depth--;
16249         }
16250         if (flags & NDR_OUT) {
16251                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
16252                 ndr->depth++;
16253                 ndr_print_ptr(ndr, "info", r->out.info);
16254                 ndr->depth++;
16255                 if (r->out.info) {
16256                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16257                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
16258                 }
16259                 ndr->depth--;
16260                 ndr_print_ptr(ndr, "needed", r->out.needed);
16261                 ndr->depth++;
16262                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16263                 ndr->depth--;
16264                 ndr_print_WERROR(ndr, "result", r->out.result);
16265                 ndr->depth--;
16266         }
16267         ndr->depth--;
16268 }
16269
16270 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
16271 {
16272         if (flags & NDR_IN) {
16273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16274                 if (r->in.servername) {
16275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16276                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16277                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16278                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16279                 }
16280                 if (r->in.info_ctr == NULL) {
16281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16282                 }
16283                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16284         }
16285         if (flags & NDR_OUT) {
16286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16287         }
16288         return NDR_ERR_SUCCESS;
16289 }
16290
16291 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
16292 {
16293         uint32_t _ptr_servername;
16294         TALLOC_CTX *_mem_save_servername_0;
16295         TALLOC_CTX *_mem_save_info_ctr_0;
16296         if (flags & NDR_IN) {
16297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16298                 if (_ptr_servername) {
16299                         NDR_PULL_ALLOC(ndr, r->in.servername);
16300                 } else {
16301                         r->in.servername = NULL;
16302                 }
16303                 if (r->in.servername) {
16304                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16305                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16306                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16307                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16308                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16309                                 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));
16310                         }
16311                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16312                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16313                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16314                 }
16315                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16316                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
16317                 }
16318                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16319                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
16320                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16321                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16322         }
16323         if (flags & NDR_OUT) {
16324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16325         }
16326         return NDR_ERR_SUCCESS;
16327 }
16328
16329 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
16330 {
16331         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
16332         ndr->depth++;
16333         if (flags & NDR_SET_VALUES) {
16334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16335         }
16336         if (flags & NDR_IN) {
16337                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
16338                 ndr->depth++;
16339                 ndr_print_ptr(ndr, "servername", r->in.servername);
16340                 ndr->depth++;
16341                 if (r->in.servername) {
16342                         ndr_print_string(ndr, "servername", r->in.servername);
16343                 }
16344                 ndr->depth--;
16345                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
16346                 ndr->depth++;
16347                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
16348                 ndr->depth--;
16349                 ndr->depth--;
16350         }
16351         if (flags & NDR_OUT) {
16352                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
16353                 ndr->depth++;
16354                 ndr_print_WERROR(ndr, "result", r->out.result);
16355                 ndr->depth--;
16356         }
16357         ndr->depth--;
16358 }
16359
16360 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
16361 {
16362         if (flags & NDR_IN) {
16363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16364                 if (r->in.server) {
16365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16368                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16369                 }
16370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16371                 if (r->in.environment) {
16372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16375                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16376                 }
16377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16378                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16379                 if (r->in.buffer) {
16380                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16381                 }
16382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16383         }
16384         if (flags & NDR_OUT) {
16385                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16386                 if (r->out.info) {
16387                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16388                 }
16389                 if (r->out.needed == NULL) {
16390                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16391                 }
16392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16393                 if (r->out.count == NULL) {
16394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16395                 }
16396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16398         }
16399         return NDR_ERR_SUCCESS;
16400 }
16401
16402 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
16403 {
16404         uint32_t _ptr_server;
16405         uint32_t _ptr_environment;
16406         uint32_t _ptr_buffer;
16407         uint32_t _ptr_info;
16408         TALLOC_CTX *_mem_save_server_0;
16409         TALLOC_CTX *_mem_save_environment_0;
16410         TALLOC_CTX *_mem_save_buffer_0;
16411         TALLOC_CTX *_mem_save_info_0;
16412         TALLOC_CTX *_mem_save_needed_0;
16413         TALLOC_CTX *_mem_save_count_0;
16414         if (flags & NDR_IN) {
16415                 ZERO_STRUCT(r->out);
16416
16417                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16418                 if (_ptr_server) {
16419                         NDR_PULL_ALLOC(ndr, r->in.server);
16420                 } else {
16421                         r->in.server = NULL;
16422                 }
16423                 if (r->in.server) {
16424                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16425                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16427                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16428                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16429                                 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));
16430                         }
16431                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16432                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16434                 }
16435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16436                 if (_ptr_environment) {
16437                         NDR_PULL_ALLOC(ndr, r->in.environment);
16438                 } else {
16439                         r->in.environment = NULL;
16440                 }
16441                 if (r->in.environment) {
16442                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16443                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16446                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16447                                 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));
16448                         }
16449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16452                 }
16453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16455                 if (_ptr_buffer) {
16456                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16457                 } else {
16458                         r->in.buffer = NULL;
16459                 }
16460                 if (r->in.buffer) {
16461                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16462                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16463                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16465                 }
16466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16467                 NDR_PULL_ALLOC(ndr, r->out.needed);
16468                 ZERO_STRUCTP(r->out.needed);
16469                 NDR_PULL_ALLOC(ndr, r->out.count);
16470                 ZERO_STRUCTP(r->out.count);
16471         }
16472         if (flags & NDR_OUT) {
16473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16474                 if (_ptr_info) {
16475                         NDR_PULL_ALLOC(ndr, r->out.info);
16476                 } else {
16477                         r->out.info = NULL;
16478                 }
16479                 if (r->out.info) {
16480                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16481                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16482                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16484                 }
16485                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16486                         NDR_PULL_ALLOC(ndr, r->out.needed);
16487                 }
16488                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16489                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16491                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16493                         NDR_PULL_ALLOC(ndr, r->out.count);
16494                 }
16495                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16496                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16499                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16500         }
16501         return NDR_ERR_SUCCESS;
16502 }
16503
16504 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
16505 {
16506         uint32_t cntr_info_0;
16507         if (flags & NDR_IN) {
16508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16510         }
16511         if (flags & NDR_OUT) {
16512                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16513                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16514                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16515                 }
16516                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16517                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16518                 }
16519         }
16520         return NDR_ERR_SUCCESS;
16521 }
16522
16523 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
16524 {
16525         uint32_t cntr_info_0;
16526         TALLOC_CTX *_mem_save_info_0;
16527         if (flags & NDR_IN) {
16528                 ZERO_STRUCT(r->out);
16529
16530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16532         }
16533         if (flags & NDR_OUT) {
16534                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16535                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16536                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16537                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16538                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16539                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16540                 }
16541                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16542                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16543                 }
16544                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16545         }
16546         return NDR_ERR_SUCCESS;
16547 }
16548
16549 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
16550 {
16551         uint32_t cntr_info_1;
16552         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
16553         ndr->depth++;
16554         if (flags & NDR_SET_VALUES) {
16555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16556         }
16557         if (flags & NDR_IN) {
16558                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
16559                 ndr->depth++;
16560                 ndr_print_ptr(ndr, "server", r->in.server);
16561                 ndr->depth++;
16562                 if (r->in.server) {
16563                         ndr_print_string(ndr, "server", r->in.server);
16564                 }
16565                 ndr->depth--;
16566                 ndr_print_ptr(ndr, "environment", r->in.environment);
16567                 ndr->depth++;
16568                 if (r->in.environment) {
16569                         ndr_print_string(ndr, "environment", r->in.environment);
16570                 }
16571                 ndr->depth--;
16572                 ndr_print_uint32(ndr, "level", r->in.level);
16573                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16574                 ndr->depth++;
16575                 if (r->in.buffer) {
16576                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16577                 }
16578                 ndr->depth--;
16579                 ndr_print_uint32(ndr, "offered", r->in.offered);
16580                 ndr->depth--;
16581         }
16582         if (flags & NDR_OUT) {
16583                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
16584                 ndr->depth++;
16585                 ndr_print_ptr(ndr, "count", r->out.count);
16586                 ndr->depth++;
16587                 ndr_print_uint32(ndr, "count", *r->out.count);
16588                 ndr->depth--;
16589                 ndr_print_ptr(ndr, "info", r->out.info);
16590                 ndr->depth++;
16591                 if (r->out.info) {
16592                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16593                         ndr->depth++;
16594                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16595                                 char *idx_1=NULL;
16596                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16597                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16598                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
16599                                         free(idx_1);
16600                                 }
16601                         }
16602                         ndr->depth--;
16603                 }
16604                 ndr->depth--;
16605                 ndr_print_ptr(ndr, "needed", r->out.needed);
16606                 ndr->depth++;
16607                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16608                 ndr->depth--;
16609                 ndr_print_WERROR(ndr, "result", r->out.result);
16610                 ndr->depth--;
16611         }
16612         ndr->depth--;
16613 }
16614
16615 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
16616 {
16617         if (flags & NDR_IN) {
16618         }
16619         if (flags & NDR_OUT) {
16620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16621         }
16622         return NDR_ERR_SUCCESS;
16623 }
16624
16625 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
16626 {
16627         if (flags & NDR_IN) {
16628         }
16629         if (flags & NDR_OUT) {
16630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16631         }
16632         return NDR_ERR_SUCCESS;
16633 }
16634
16635 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
16636 {
16637         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
16638         ndr->depth++;
16639         if (flags & NDR_SET_VALUES) {
16640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16641         }
16642         if (flags & NDR_IN) {
16643                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
16644                 ndr->depth++;
16645                 ndr->depth--;
16646         }
16647         if (flags & NDR_OUT) {
16648                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
16649                 ndr->depth++;
16650                 ndr_print_WERROR(ndr, "result", r->out.result);
16651                 ndr->depth--;
16652         }
16653         ndr->depth--;
16654 }
16655
16656 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16657 {
16658         if (flags & NDR_IN) {
16659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16660                 if (r->in.server) {
16661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16665                 }
16666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16667                 if (r->in.environment) {
16668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16671                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16672                 }
16673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16675                 if (r->in.buffer) {
16676                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16677                 }
16678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16679         }
16680         if (flags & NDR_OUT) {
16681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16682                 if (r->out.info) {
16683                         {
16684                                 struct ndr_push *_ndr_info;
16685                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16686                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16687                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16688                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16689                         }
16690                 }
16691                 if (r->out.needed == NULL) {
16692                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16693                 }
16694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16695                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16696         }
16697         return NDR_ERR_SUCCESS;
16698 }
16699
16700 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
16701 {
16702         uint32_t _ptr_server;
16703         uint32_t _ptr_environment;
16704         uint32_t _ptr_buffer;
16705         uint32_t _ptr_info;
16706         TALLOC_CTX *_mem_save_server_0;
16707         TALLOC_CTX *_mem_save_environment_0;
16708         TALLOC_CTX *_mem_save_buffer_0;
16709         TALLOC_CTX *_mem_save_info_0;
16710         TALLOC_CTX *_mem_save_needed_0;
16711         if (flags & NDR_IN) {
16712                 ZERO_STRUCT(r->out);
16713
16714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16715                 if (_ptr_server) {
16716                         NDR_PULL_ALLOC(ndr, r->in.server);
16717                 } else {
16718                         r->in.server = NULL;
16719                 }
16720                 if (r->in.server) {
16721                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16722                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16723                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16724                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16725                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16726                                 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));
16727                         }
16728                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16729                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16731                 }
16732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16733                 if (_ptr_environment) {
16734                         NDR_PULL_ALLOC(ndr, r->in.environment);
16735                 } else {
16736                         r->in.environment = NULL;
16737                 }
16738                 if (r->in.environment) {
16739                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16740                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16743                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16744                                 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));
16745                         }
16746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16749                 }
16750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16752                 if (_ptr_buffer) {
16753                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16754                 } else {
16755                         r->in.buffer = NULL;
16756                 }
16757                 if (r->in.buffer) {
16758                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16759                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16760                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16762                 }
16763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16764                 NDR_PULL_ALLOC(ndr, r->out.needed);
16765                 ZERO_STRUCTP(r->out.needed);
16766         }
16767         if (flags & NDR_OUT) {
16768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16769                 if (_ptr_info) {
16770                         NDR_PULL_ALLOC(ndr, r->out.info);
16771                 } else {
16772                         r->out.info = NULL;
16773                 }
16774                 if (r->out.info) {
16775                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16776                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16777                         {
16778                                 struct ndr_pull *_ndr_info;
16779                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16780                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16781                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16782                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16783                         }
16784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16785                 }
16786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16787                         NDR_PULL_ALLOC(ndr, r->out.needed);
16788                 }
16789                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16790                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16793                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16794         }
16795         return NDR_ERR_SUCCESS;
16796 }
16797
16798 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16799 {
16800         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
16801         ndr->depth++;
16802         if (flags & NDR_SET_VALUES) {
16803                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16804         }
16805         if (flags & NDR_IN) {
16806                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
16807                 ndr->depth++;
16808                 ndr_print_ptr(ndr, "server", r->in.server);
16809                 ndr->depth++;
16810                 if (r->in.server) {
16811                         ndr_print_string(ndr, "server", r->in.server);
16812                 }
16813                 ndr->depth--;
16814                 ndr_print_ptr(ndr, "environment", r->in.environment);
16815                 ndr->depth++;
16816                 if (r->in.environment) {
16817                         ndr_print_string(ndr, "environment", r->in.environment);
16818                 }
16819                 ndr->depth--;
16820                 ndr_print_uint32(ndr, "level", r->in.level);
16821                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16822                 ndr->depth++;
16823                 if (r->in.buffer) {
16824                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16825                 }
16826                 ndr->depth--;
16827                 ndr_print_uint32(ndr, "offered", r->in.offered);
16828                 ndr->depth--;
16829         }
16830         if (flags & NDR_OUT) {
16831                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
16832                 ndr->depth++;
16833                 ndr_print_ptr(ndr, "info", r->out.info);
16834                 ndr->depth++;
16835                 if (r->out.info) {
16836                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16837                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
16838                 }
16839                 ndr->depth--;
16840                 ndr_print_ptr(ndr, "needed", r->out.needed);
16841                 ndr->depth++;
16842                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16843                 ndr->depth--;
16844                 ndr_print_WERROR(ndr, "result", r->out.result);
16845                 ndr->depth--;
16846         }
16847         ndr->depth--;
16848 }
16849
16850 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
16851 {
16852         if (flags & NDR_IN) {
16853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16854                 if (r->in.server) {
16855                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16858                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16859                 }
16860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16863                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16867                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16868         }
16869         if (flags & NDR_OUT) {
16870                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16871         }
16872         return NDR_ERR_SUCCESS;
16873 }
16874
16875 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
16876 {
16877         uint32_t _ptr_server;
16878         TALLOC_CTX *_mem_save_server_0;
16879         if (flags & NDR_IN) {
16880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16881                 if (_ptr_server) {
16882                         NDR_PULL_ALLOC(ndr, r->in.server);
16883                 } else {
16884                         r->in.server = NULL;
16885                 }
16886                 if (r->in.server) {
16887                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16888                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16889                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16890                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16891                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16892                                 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));
16893                         }
16894                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16895                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16897                 }
16898                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16899                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16900                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16901                         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));
16902                 }
16903                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16904                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16905                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16906                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16907                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16908                         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));
16909                 }
16910                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16911                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16912         }
16913         if (flags & NDR_OUT) {
16914                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16915         }
16916         return NDR_ERR_SUCCESS;
16917 }
16918
16919 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
16920 {
16921         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
16922         ndr->depth++;
16923         if (flags & NDR_SET_VALUES) {
16924                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16925         }
16926         if (flags & NDR_IN) {
16927                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
16928                 ndr->depth++;
16929                 ndr_print_ptr(ndr, "server", r->in.server);
16930                 ndr->depth++;
16931                 if (r->in.server) {
16932                         ndr_print_string(ndr, "server", r->in.server);
16933                 }
16934                 ndr->depth--;
16935                 ndr_print_string(ndr, "architecture", r->in.architecture);
16936                 ndr_print_string(ndr, "driver", r->in.driver);
16937                 ndr->depth--;
16938         }
16939         if (flags & NDR_OUT) {
16940                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
16941                 ndr->depth++;
16942                 ndr_print_WERROR(ndr, "result", r->out.result);
16943                 ndr->depth--;
16944         }
16945         ndr->depth--;
16946 }
16947
16948 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
16949 {
16950         if (flags & NDR_IN) {
16951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16952                 if (r->in.server) {
16953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16957                 }
16958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16961                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16965                 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));
16966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16969                 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));
16970         }
16971         if (flags & NDR_OUT) {
16972                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16973         }
16974         return NDR_ERR_SUCCESS;
16975 }
16976
16977 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
16978 {
16979         uint32_t _ptr_server;
16980         TALLOC_CTX *_mem_save_server_0;
16981         if (flags & NDR_IN) {
16982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16983                 if (_ptr_server) {
16984                         NDR_PULL_ALLOC(ndr, r->in.server);
16985                 } else {
16986                         r->in.server = NULL;
16987                 }
16988                 if (r->in.server) {
16989                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16990                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16991                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16992                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16993                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16994                                 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));
16995                         }
16996                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16997                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16998                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16999                 }
17000                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
17001                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
17002                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
17003                         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));
17004                 }
17005                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
17006                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
17007                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
17008                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
17009                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
17010                         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));
17011                 }
17012                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
17013                 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));
17014                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
17015                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
17016                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
17017                         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));
17018                 }
17019                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
17020                 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));
17021         }
17022         if (flags & NDR_OUT) {
17023                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17024         }
17025         return NDR_ERR_SUCCESS;
17026 }
17027
17028 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
17029 {
17030         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
17031         ndr->depth++;
17032         if (flags & NDR_SET_VALUES) {
17033                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17034         }
17035         if (flags & NDR_IN) {
17036                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
17037                 ndr->depth++;
17038                 ndr_print_ptr(ndr, "server", r->in.server);
17039                 ndr->depth++;
17040                 if (r->in.server) {
17041                         ndr_print_string(ndr, "server", r->in.server);
17042                 }
17043                 ndr->depth--;
17044                 ndr_print_string(ndr, "architecture", r->in.architecture);
17045                 ndr_print_string(ndr, "path_name", r->in.path_name);
17046                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
17047                 ndr->depth--;
17048         }
17049         if (flags & NDR_OUT) {
17050                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
17051                 ndr->depth++;
17052                 ndr_print_WERROR(ndr, "result", r->out.result);
17053                 ndr->depth--;
17054         }
17055         ndr->depth--;
17056 }
17057
17058 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
17059 {
17060         if (flags & NDR_IN) {
17061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
17062                 if (r->in.servername) {
17063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
17064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
17066                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17067                 }
17068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
17069                 if (r->in.environment) {
17070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17073                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17074                 }
17075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17077                 if (r->in.buffer) {
17078                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17079                 }
17080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17081         }
17082         if (flags & NDR_OUT) {
17083                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17084                 if (r->out.info) {
17085                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
17086                 }
17087                 if (r->out.needed == NULL) {
17088                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17089                 }
17090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17091                 if (r->out.count == NULL) {
17092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17093                 }
17094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
17095                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17096         }
17097         return NDR_ERR_SUCCESS;
17098 }
17099
17100 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
17101 {
17102         uint32_t _ptr_servername;
17103         uint32_t _ptr_environment;
17104         uint32_t _ptr_buffer;
17105         uint32_t _ptr_info;
17106         TALLOC_CTX *_mem_save_servername_0;
17107         TALLOC_CTX *_mem_save_environment_0;
17108         TALLOC_CTX *_mem_save_buffer_0;
17109         TALLOC_CTX *_mem_save_info_0;
17110         TALLOC_CTX *_mem_save_needed_0;
17111         TALLOC_CTX *_mem_save_count_0;
17112         if (flags & NDR_IN) {
17113                 ZERO_STRUCT(r->out);
17114
17115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
17116                 if (_ptr_servername) {
17117                         NDR_PULL_ALLOC(ndr, r->in.servername);
17118                 } else {
17119                         r->in.servername = NULL;
17120                 }
17121                 if (r->in.servername) {
17122                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
17123                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
17124                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
17125                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
17126                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
17127                                 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));
17128                         }
17129                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
17130                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
17131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
17132                 }
17133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17134                 if (_ptr_environment) {
17135                         NDR_PULL_ALLOC(ndr, r->in.environment);
17136                 } else {
17137                         r->in.environment = NULL;
17138                 }
17139                 if (r->in.environment) {
17140                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17141                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
17142                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
17143                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
17144                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
17145                                 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));
17146                         }
17147                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
17148                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
17149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17150                 }
17151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17153                 if (_ptr_buffer) {
17154                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17155                 } else {
17156                         r->in.buffer = NULL;
17157                 }
17158                 if (r->in.buffer) {
17159                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17160                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17161                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17163                 }
17164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17165                 NDR_PULL_ALLOC(ndr, r->out.needed);
17166                 ZERO_STRUCTP(r->out.needed);
17167                 NDR_PULL_ALLOC(ndr, r->out.count);
17168                 ZERO_STRUCTP(r->out.count);
17169         }
17170         if (flags & NDR_OUT) {
17171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17172                 if (_ptr_info) {
17173                         NDR_PULL_ALLOC(ndr, r->out.info);
17174                 } else {
17175                         r->out.info = NULL;
17176                 }
17177                 if (r->out.info) {
17178                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17179                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17180                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
17181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17182                 }
17183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17184                         NDR_PULL_ALLOC(ndr, r->out.needed);
17185                 }
17186                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17187                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17191                         NDR_PULL_ALLOC(ndr, r->out.count);
17192                 }
17193                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
17194                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
17195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
17196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
17197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17198         }
17199         return NDR_ERR_SUCCESS;
17200 }
17201
17202 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
17203 {
17204         uint32_t cntr_info_0;
17205         if (flags & NDR_IN) {
17206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
17208         }
17209         if (flags & NDR_OUT) {
17210                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17211                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
17212                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
17213                 }
17214                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17215                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
17216                 }
17217         }
17218         return NDR_ERR_SUCCESS;
17219 }
17220
17221 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
17222 {
17223         uint32_t cntr_info_0;
17224         TALLOC_CTX *_mem_save_info_0;
17225         if (flags & NDR_IN) {
17226                 ZERO_STRUCT(r->out);
17227
17228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
17230         }
17231         if (flags & NDR_OUT) {
17232                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
17233                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17234                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17235                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17236                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
17237                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
17238                 }
17239                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17240                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
17241                 }
17242                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17243         }
17244         return NDR_ERR_SUCCESS;
17245 }
17246
17247 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
17248 {
17249         uint32_t cntr_info_1;
17250         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
17251         ndr->depth++;
17252         if (flags & NDR_SET_VALUES) {
17253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17254         }
17255         if (flags & NDR_IN) {
17256                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
17257                 ndr->depth++;
17258                 ndr_print_ptr(ndr, "servername", r->in.servername);
17259                 ndr->depth++;
17260                 if (r->in.servername) {
17261                         ndr_print_string(ndr, "servername", r->in.servername);
17262                 }
17263                 ndr->depth--;
17264                 ndr_print_ptr(ndr, "environment", r->in.environment);
17265                 ndr->depth++;
17266                 if (r->in.environment) {
17267                         ndr_print_string(ndr, "environment", r->in.environment);
17268                 }
17269                 ndr->depth--;
17270                 ndr_print_uint32(ndr, "level", r->in.level);
17271                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17272                 ndr->depth++;
17273                 if (r->in.buffer) {
17274                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17275                 }
17276                 ndr->depth--;
17277                 ndr_print_uint32(ndr, "offered", r->in.offered);
17278                 ndr->depth--;
17279         }
17280         if (flags & NDR_OUT) {
17281                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
17282                 ndr->depth++;
17283                 ndr_print_ptr(ndr, "count", r->out.count);
17284                 ndr->depth++;
17285                 ndr_print_uint32(ndr, "count", *r->out.count);
17286                 ndr->depth--;
17287                 ndr_print_ptr(ndr, "info", r->out.info);
17288                 ndr->depth++;
17289                 if (r->out.info) {
17290                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
17291                         ndr->depth++;
17292                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
17293                                 char *idx_1=NULL;
17294                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
17295                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
17296                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
17297                                         free(idx_1);
17298                                 }
17299                         }
17300                         ndr->depth--;
17301                 }
17302                 ndr->depth--;
17303                 ndr_print_ptr(ndr, "needed", r->out.needed);
17304                 ndr->depth++;
17305                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17306                 ndr->depth--;
17307                 ndr_print_WERROR(ndr, "result", r->out.result);
17308                 ndr->depth--;
17309         }
17310         ndr->depth--;
17311 }
17312
17313 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
17314 {
17315         if (flags & NDR_IN) {
17316                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
17317                 if (r->in.server) {
17318                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
17319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
17321                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17322                 }
17323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
17324                 if (r->in.environment) {
17325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17328                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17329                 }
17330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17332                 if (r->in.buffer) {
17333                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17334                 }
17335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17336         }
17337         if (flags & NDR_OUT) {
17338                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17339                 if (r->out.info) {
17340                         {
17341                                 struct ndr_push *_ndr_info;
17342                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17343                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
17344                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17345                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17346                         }
17347                 }
17348                 if (r->out.needed == NULL) {
17349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17350                 }
17351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17353         }
17354         return NDR_ERR_SUCCESS;
17355 }
17356
17357 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
17358 {
17359         uint32_t _ptr_server;
17360         uint32_t _ptr_environment;
17361         uint32_t _ptr_buffer;
17362         uint32_t _ptr_info;
17363         TALLOC_CTX *_mem_save_server_0;
17364         TALLOC_CTX *_mem_save_environment_0;
17365         TALLOC_CTX *_mem_save_buffer_0;
17366         TALLOC_CTX *_mem_save_info_0;
17367         TALLOC_CTX *_mem_save_needed_0;
17368         if (flags & NDR_IN) {
17369                 ZERO_STRUCT(r->out);
17370
17371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
17372                 if (_ptr_server) {
17373                         NDR_PULL_ALLOC(ndr, r->in.server);
17374                 } else {
17375                         r->in.server = NULL;
17376                 }
17377                 if (r->in.server) {
17378                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
17379                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
17380                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
17381                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
17382                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
17383                                 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));
17384                         }
17385                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
17386                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
17387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
17388                 }
17389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17390                 if (_ptr_environment) {
17391                         NDR_PULL_ALLOC(ndr, r->in.environment);
17392                 } else {
17393                         r->in.environment = NULL;
17394                 }
17395                 if (r->in.environment) {
17396                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17397                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
17398                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
17399                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
17400                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
17401                                 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));
17402                         }
17403                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
17404                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
17405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17406                 }
17407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17408                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17409                 if (_ptr_buffer) {
17410                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17411                 } else {
17412                         r->in.buffer = NULL;
17413                 }
17414                 if (r->in.buffer) {
17415                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17416                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17417                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17418                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17419                 }
17420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17421                 NDR_PULL_ALLOC(ndr, r->out.needed);
17422                 ZERO_STRUCTP(r->out.needed);
17423         }
17424         if (flags & NDR_OUT) {
17425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17426                 if (_ptr_info) {
17427                         NDR_PULL_ALLOC(ndr, r->out.info);
17428                 } else {
17429                         r->out.info = NULL;
17430                 }
17431                 if (r->out.info) {
17432                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17433                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17434                         {
17435                                 struct ndr_pull *_ndr_info;
17436                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17437                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
17438                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17439                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17440                         }
17441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17442                 }
17443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17444                         NDR_PULL_ALLOC(ndr, r->out.needed);
17445                 }
17446                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17447                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17450                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17451         }
17452         return NDR_ERR_SUCCESS;
17453 }
17454
17455 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
17456 {
17457         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
17458         ndr->depth++;
17459         if (flags & NDR_SET_VALUES) {
17460                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17461         }
17462         if (flags & NDR_IN) {
17463                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
17464                 ndr->depth++;
17465                 ndr_print_ptr(ndr, "server", r->in.server);
17466                 ndr->depth++;
17467                 if (r->in.server) {
17468                         ndr_print_string(ndr, "server", r->in.server);
17469                 }
17470                 ndr->depth--;
17471                 ndr_print_ptr(ndr, "environment", r->in.environment);
17472                 ndr->depth++;
17473                 if (r->in.environment) {
17474                         ndr_print_string(ndr, "environment", r->in.environment);
17475                 }
17476                 ndr->depth--;
17477                 ndr_print_uint32(ndr, "level", r->in.level);
17478                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17479                 ndr->depth++;
17480                 if (r->in.buffer) {
17481                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17482                 }
17483                 ndr->depth--;
17484                 ndr_print_uint32(ndr, "offered", r->in.offered);
17485                 ndr->depth--;
17486         }
17487         if (flags & NDR_OUT) {
17488                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
17489                 ndr->depth++;
17490                 ndr_print_ptr(ndr, "info", r->out.info);
17491                 ndr->depth++;
17492                 if (r->out.info) {
17493                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
17494                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
17495                 }
17496                 ndr->depth--;
17497                 ndr_print_ptr(ndr, "needed", r->out.needed);
17498                 ndr->depth++;
17499                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17500                 ndr->depth--;
17501                 ndr_print_WERROR(ndr, "result", r->out.result);
17502                 ndr->depth--;
17503         }
17504         ndr->depth--;
17505 }
17506
17507 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
17508 {
17509         if (flags & NDR_IN) {
17510                 if (r->in.handle == NULL) {
17511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17512                 }
17513                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17515                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
17516                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17517         }
17518         if (flags & NDR_OUT) {
17519                 if (r->out.job_id == NULL) {
17520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17521                 }
17522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
17523                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17524         }
17525         return NDR_ERR_SUCCESS;
17526 }
17527
17528 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
17529 {
17530         TALLOC_CTX *_mem_save_handle_0;
17531         TALLOC_CTX *_mem_save_job_id_0;
17532         if (flags & NDR_IN) {
17533                 ZERO_STRUCT(r->out);
17534
17535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17536                         NDR_PULL_ALLOC(ndr, r->in.handle);
17537                 }
17538                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17539                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17540                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17543                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17544                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17545                 NDR_PULL_ALLOC(ndr, r->out.job_id);
17546                 ZERO_STRUCTP(r->out.job_id);
17547         }
17548         if (flags & NDR_OUT) {
17549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17550                         NDR_PULL_ALLOC(ndr, r->out.job_id);
17551                 }
17552                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
17553                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
17554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
17555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
17556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17557         }
17558         return NDR_ERR_SUCCESS;
17559 }
17560
17561 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
17562 {
17563         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
17564         ndr->depth++;
17565         if (flags & NDR_SET_VALUES) {
17566                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17567         }
17568         if (flags & NDR_IN) {
17569                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
17570                 ndr->depth++;
17571                 ndr_print_ptr(ndr, "handle", r->in.handle);
17572                 ndr->depth++;
17573                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17574                 ndr->depth--;
17575                 ndr_print_uint32(ndr, "level", r->in.level);
17576                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
17577                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
17578                 ndr->depth--;
17579         }
17580         if (flags & NDR_OUT) {
17581                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
17582                 ndr->depth++;
17583                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
17584                 ndr->depth++;
17585                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
17586                 ndr->depth--;
17587                 ndr_print_WERROR(ndr, "result", r->out.result);
17588                 ndr->depth--;
17589         }
17590         ndr->depth--;
17591 }
17592
17593 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
17594 {
17595         if (flags & NDR_IN) {
17596                 if (r->in.handle == NULL) {
17597                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17598                 }
17599                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17600         }
17601         if (flags & NDR_OUT) {
17602                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17603         }
17604         return NDR_ERR_SUCCESS;
17605 }
17606
17607 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
17608 {
17609         TALLOC_CTX *_mem_save_handle_0;
17610         if (flags & NDR_IN) {
17611                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17612                         NDR_PULL_ALLOC(ndr, r->in.handle);
17613                 }
17614                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17615                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17616                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17618         }
17619         if (flags & NDR_OUT) {
17620                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17621         }
17622         return NDR_ERR_SUCCESS;
17623 }
17624
17625 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
17626 {
17627         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
17628         ndr->depth++;
17629         if (flags & NDR_SET_VALUES) {
17630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17631         }
17632         if (flags & NDR_IN) {
17633                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
17634                 ndr->depth++;
17635                 ndr_print_ptr(ndr, "handle", r->in.handle);
17636                 ndr->depth++;
17637                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17638                 ndr->depth--;
17639                 ndr->depth--;
17640         }
17641         if (flags & NDR_OUT) {
17642                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
17643                 ndr->depth++;
17644                 ndr_print_WERROR(ndr, "result", r->out.result);
17645                 ndr->depth--;
17646         }
17647         ndr->depth--;
17648 }
17649
17650 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
17651 {
17652         if (flags & NDR_IN) {
17653                 if (r->in.handle == NULL) {
17654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17655                 }
17656                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17657                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
17659         }
17660         if (flags & NDR_OUT) {
17661                 if (r->out.num_written == NULL) {
17662                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17663                 }
17664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
17665                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17666         }
17667         return NDR_ERR_SUCCESS;
17668 }
17669
17670 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
17671 {
17672         TALLOC_CTX *_mem_save_handle_0;
17673         TALLOC_CTX *_mem_save_num_written_0;
17674         if (flags & NDR_IN) {
17675                 ZERO_STRUCT(r->out);
17676
17677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17678                         NDR_PULL_ALLOC(ndr, r->in.handle);
17679                 }
17680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17684                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
17685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
17686                 NDR_PULL_ALLOC(ndr, r->out.num_written);
17687                 ZERO_STRUCTP(r->out.num_written);
17688         }
17689         if (flags & NDR_OUT) {
17690                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17691                         NDR_PULL_ALLOC(ndr, r->out.num_written);
17692                 }
17693                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
17694                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
17695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
17696                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
17697                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17698         }
17699         return NDR_ERR_SUCCESS;
17700 }
17701
17702 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
17703 {
17704         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
17705         ndr->depth++;
17706         if (flags & NDR_SET_VALUES) {
17707                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17708         }
17709         if (flags & NDR_IN) {
17710                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
17711                 ndr->depth++;
17712                 ndr_print_ptr(ndr, "handle", r->in.handle);
17713                 ndr->depth++;
17714                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17715                 ndr->depth--;
17716                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
17717                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
17718                 ndr->depth--;
17719         }
17720         if (flags & NDR_OUT) {
17721                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
17722                 ndr->depth++;
17723                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
17724                 ndr->depth++;
17725                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
17726                 ndr->depth--;
17727                 ndr_print_WERROR(ndr, "result", r->out.result);
17728                 ndr->depth--;
17729         }
17730         ndr->depth--;
17731 }
17732
17733 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
17734 {
17735         if (flags & NDR_IN) {
17736                 if (r->in.handle == NULL) {
17737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17738                 }
17739                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17740         }
17741         if (flags & NDR_OUT) {
17742                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17743         }
17744         return NDR_ERR_SUCCESS;
17745 }
17746
17747 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
17748 {
17749         TALLOC_CTX *_mem_save_handle_0;
17750         if (flags & NDR_IN) {
17751                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17752                         NDR_PULL_ALLOC(ndr, r->in.handle);
17753                 }
17754                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17755                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17756                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17757                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17758         }
17759         if (flags & NDR_OUT) {
17760                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17761         }
17762         return NDR_ERR_SUCCESS;
17763 }
17764
17765 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
17766 {
17767         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
17768         ndr->depth++;
17769         if (flags & NDR_SET_VALUES) {
17770                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17771         }
17772         if (flags & NDR_IN) {
17773                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
17774                 ndr->depth++;
17775                 ndr_print_ptr(ndr, "handle", r->in.handle);
17776                 ndr->depth++;
17777                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17778                 ndr->depth--;
17779                 ndr->depth--;
17780         }
17781         if (flags & NDR_OUT) {
17782                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
17783                 ndr->depth++;
17784                 ndr_print_WERROR(ndr, "result", r->out.result);
17785                 ndr->depth--;
17786         }
17787         ndr->depth--;
17788 }
17789
17790 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
17791 {
17792         if (flags & NDR_IN) {
17793                 if (r->in.handle == NULL) {
17794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17795                 }
17796                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17797         }
17798         if (flags & NDR_OUT) {
17799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17800         }
17801         return NDR_ERR_SUCCESS;
17802 }
17803
17804 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
17805 {
17806         TALLOC_CTX *_mem_save_handle_0;
17807         if (flags & NDR_IN) {
17808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17809                         NDR_PULL_ALLOC(ndr, r->in.handle);
17810                 }
17811                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17813                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17815         }
17816         if (flags & NDR_OUT) {
17817                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17818         }
17819         return NDR_ERR_SUCCESS;
17820 }
17821
17822 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
17823 {
17824         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
17825         ndr->depth++;
17826         if (flags & NDR_SET_VALUES) {
17827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17828         }
17829         if (flags & NDR_IN) {
17830                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
17831                 ndr->depth++;
17832                 ndr_print_ptr(ndr, "handle", r->in.handle);
17833                 ndr->depth++;
17834                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17835                 ndr->depth--;
17836                 ndr->depth--;
17837         }
17838         if (flags & NDR_OUT) {
17839                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
17840                 ndr->depth++;
17841                 ndr_print_WERROR(ndr, "result", r->out.result);
17842                 ndr->depth--;
17843         }
17844         ndr->depth--;
17845 }
17846
17847 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
17848 {
17849         if (flags & NDR_IN) {
17850                 if (r->in.handle == NULL) {
17851                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17852                 }
17853                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17855         }
17856         if (flags & NDR_OUT) {
17857                 if (r->out.data == NULL) {
17858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17859                 }
17860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17861                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
17862                 if (r->out._data_size == NULL) {
17863                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17864                 }
17865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
17866                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17867         }
17868         return NDR_ERR_SUCCESS;
17869 }
17870
17871 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
17872 {
17873         TALLOC_CTX *_mem_save_handle_0;
17874         TALLOC_CTX *_mem_save__data_size_0;
17875         if (flags & NDR_IN) {
17876                 ZERO_STRUCT(r->out);
17877
17878                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17879                         NDR_PULL_ALLOC(ndr, r->in.handle);
17880                 }
17881                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17882                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17883                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17884                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
17886                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
17887                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
17888                 NDR_PULL_ALLOC(ndr, r->out._data_size);
17889                 ZERO_STRUCTP(r->out._data_size);
17890         }
17891         if (flags & NDR_OUT) {
17892                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
17893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17894                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
17895                 }
17896                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
17897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17898                         NDR_PULL_ALLOC(ndr, r->out._data_size);
17899                 }
17900                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
17901                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
17902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
17903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
17904                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17905                 if (r->out.data) {
17906                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
17907                 }
17908         }
17909         return NDR_ERR_SUCCESS;
17910 }
17911
17912 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
17913 {
17914         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
17915         ndr->depth++;
17916         if (flags & NDR_SET_VALUES) {
17917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17918         }
17919         if (flags & NDR_IN) {
17920                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
17921                 ndr->depth++;
17922                 ndr_print_ptr(ndr, "handle", r->in.handle);
17923                 ndr->depth++;
17924                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17925                 ndr->depth--;
17926                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
17927                 ndr->depth--;
17928         }
17929         if (flags & NDR_OUT) {
17930                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
17931                 ndr->depth++;
17932                 ndr_print_ptr(ndr, "data", r->out.data);
17933                 ndr->depth++;
17934                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
17935                 ndr->depth--;
17936                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
17937                 ndr->depth++;
17938                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
17939                 ndr->depth--;
17940                 ndr_print_WERROR(ndr, "result", r->out.result);
17941                 ndr->depth--;
17942         }
17943         ndr->depth--;
17944 }
17945
17946 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
17947 {
17948         if (flags & NDR_IN) {
17949                 if (r->in.handle == NULL) {
17950                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17951                 }
17952                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17953         }
17954         if (flags & NDR_OUT) {
17955                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17956         }
17957         return NDR_ERR_SUCCESS;
17958 }
17959
17960 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
17961 {
17962         TALLOC_CTX *_mem_save_handle_0;
17963         if (flags & NDR_IN) {
17964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17965                         NDR_PULL_ALLOC(ndr, r->in.handle);
17966                 }
17967                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17968                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17969                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17971         }
17972         if (flags & NDR_OUT) {
17973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17974         }
17975         return NDR_ERR_SUCCESS;
17976 }
17977
17978 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
17979 {
17980         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
17981         ndr->depth++;
17982         if (flags & NDR_SET_VALUES) {
17983                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17984         }
17985         if (flags & NDR_IN) {
17986                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
17987                 ndr->depth++;
17988                 ndr_print_ptr(ndr, "handle", r->in.handle);
17989                 ndr->depth++;
17990                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17991                 ndr->depth--;
17992                 ndr->depth--;
17993         }
17994         if (flags & NDR_OUT) {
17995                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
17996                 ndr->depth++;
17997                 ndr_print_WERROR(ndr, "result", r->out.result);
17998                 ndr->depth--;
17999         }
18000         ndr->depth--;
18001 }
18002
18003 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
18004 {
18005         if (flags & NDR_IN) {
18006                 if (r->in.handle == NULL) {
18007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18008                 }
18009                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18012                 if (r->in.buffer) {
18013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18014                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
18015                 }
18016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18017         }
18018         if (flags & NDR_OUT) {
18019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
18020                 if (r->out.buffer) {
18021                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18022                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
18023                 }
18024                 if (r->out.needed == NULL) {
18025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18026                 }
18027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18028                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18029         }
18030         return NDR_ERR_SUCCESS;
18031 }
18032
18033 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
18034 {
18035         uint32_t _ptr_buffer;
18036         TALLOC_CTX *_mem_save_handle_0;
18037         TALLOC_CTX *_mem_save_buffer_0;
18038         TALLOC_CTX *_mem_save_needed_0;
18039         if (flags & NDR_IN) {
18040                 ZERO_STRUCT(r->out);
18041
18042                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18043                         NDR_PULL_ALLOC(ndr, r->in.handle);
18044                 }
18045                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18046                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18047                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18048                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18051                 if (_ptr_buffer) {
18052                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18053                 } else {
18054                         r->in.buffer = NULL;
18055                 }
18056                 if (r->in.buffer) {
18057                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18058                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18059                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
18060                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
18061                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
18062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18063                 }
18064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18065                 NDR_PULL_ALLOC(ndr, r->out.needed);
18066                 ZERO_STRUCTP(r->out.needed);
18067                 if (r->in.buffer) {
18068                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
18069                 }
18070         }
18071         if (flags & NDR_OUT) {
18072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18073                 if (_ptr_buffer) {
18074                         NDR_PULL_ALLOC(ndr, r->out.buffer);
18075                 } else {
18076                         r->out.buffer = NULL;
18077                 }
18078                 if (r->out.buffer) {
18079                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18080                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
18081                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
18082                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
18083                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
18084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18085                 }
18086                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18087                         NDR_PULL_ALLOC(ndr, r->out.needed);
18088                 }
18089                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18090                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18092                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18094                 if (r->out.buffer) {
18095                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
18096                 }
18097         }
18098         return NDR_ERR_SUCCESS;
18099 }
18100
18101 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
18102 {
18103         ndr_print_struct(ndr, name, "spoolss_AddJob");
18104         ndr->depth++;
18105         if (flags & NDR_SET_VALUES) {
18106                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18107         }
18108         if (flags & NDR_IN) {
18109                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
18110                 ndr->depth++;
18111                 ndr_print_ptr(ndr, "handle", r->in.handle);
18112                 ndr->depth++;
18113                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18114                 ndr->depth--;
18115                 ndr_print_uint32(ndr, "level", r->in.level);
18116                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18117                 ndr->depth++;
18118                 if (r->in.buffer) {
18119                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
18120                 }
18121                 ndr->depth--;
18122                 ndr_print_uint32(ndr, "offered", r->in.offered);
18123                 ndr->depth--;
18124         }
18125         if (flags & NDR_OUT) {
18126                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
18127                 ndr->depth++;
18128                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
18129                 ndr->depth++;
18130                 if (r->out.buffer) {
18131                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
18132                 }
18133                 ndr->depth--;
18134                 ndr_print_ptr(ndr, "needed", r->out.needed);
18135                 ndr->depth++;
18136                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18137                 ndr->depth--;
18138                 ndr_print_WERROR(ndr, "result", r->out.result);
18139                 ndr->depth--;
18140         }
18141         ndr->depth--;
18142 }
18143
18144 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
18145 {
18146         if (flags & NDR_IN) {
18147                 if (r->in.handle == NULL) {
18148                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18149                 }
18150                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
18152         }
18153         if (flags & NDR_OUT) {
18154                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18155         }
18156         return NDR_ERR_SUCCESS;
18157 }
18158
18159 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
18160 {
18161         TALLOC_CTX *_mem_save_handle_0;
18162         if (flags & NDR_IN) {
18163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18164                         NDR_PULL_ALLOC(ndr, r->in.handle);
18165                 }
18166                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18167                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18168                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
18171         }
18172         if (flags & NDR_OUT) {
18173                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18174         }
18175         return NDR_ERR_SUCCESS;
18176 }
18177
18178 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
18179 {
18180         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
18181         ndr->depth++;
18182         if (flags & NDR_SET_VALUES) {
18183                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18184         }
18185         if (flags & NDR_IN) {
18186                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
18187                 ndr->depth++;
18188                 ndr_print_ptr(ndr, "handle", r->in.handle);
18189                 ndr->depth++;
18190                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18191                 ndr->depth--;
18192                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
18193                 ndr->depth--;
18194         }
18195         if (flags & NDR_OUT) {
18196                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
18197                 ndr->depth++;
18198                 ndr_print_WERROR(ndr, "result", r->out.result);
18199                 ndr->depth--;
18200         }
18201         ndr->depth--;
18202 }
18203
18204 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
18205 {
18206         if (flags & NDR_IN) {
18207                 if (r->in.handle == NULL) {
18208                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18209                 }
18210                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
18212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
18214                 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));
18215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18216         }
18217         if (flags & NDR_OUT) {
18218                 if (r->out.type == NULL) {
18219                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18220                 }
18221                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
18222                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
18223                 if (r->out.needed == NULL) {
18224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18225                 }
18226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18228         }
18229         return NDR_ERR_SUCCESS;
18230 }
18231
18232 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
18233 {
18234         TALLOC_CTX *_mem_save_handle_0;
18235         TALLOC_CTX *_mem_save_type_0;
18236         TALLOC_CTX *_mem_save_needed_0;
18237         if (flags & NDR_IN) {
18238                 ZERO_STRUCT(r->out);
18239
18240                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18241                         NDR_PULL_ALLOC(ndr, r->in.handle);
18242                 }
18243                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18244                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18245                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18246                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18247                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
18248                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
18249                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
18250                         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));
18251                 }
18252                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
18253                 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));
18254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18255                 NDR_PULL_ALLOC(ndr, r->out.type);
18256                 ZERO_STRUCTP(r->out.type);
18257                 NDR_PULL_ALLOC(ndr, r->out.needed);
18258                 ZERO_STRUCTP(r->out.needed);
18259         }
18260         if (flags & NDR_OUT) {
18261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18262                         NDR_PULL_ALLOC(ndr, r->out.type);
18263                 }
18264                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
18265                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
18266                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
18267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
18268                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
18269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18270                         NDR_PULL_ALLOC(ndr, r->out.needed);
18271                 }
18272                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18273                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18277         }
18278         return NDR_ERR_SUCCESS;
18279 }
18280
18281 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
18282 {
18283         if (flags & NDR_IN) {
18284                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
18285         }
18286         if (flags & NDR_OUT) {
18287                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
18288                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
18289         }
18290         return NDR_ERR_SUCCESS;
18291 }
18292
18293 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
18294 {
18295         if (flags & NDR_IN) {
18296                 ZERO_STRUCT(r->out);
18297
18298                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
18299         }
18300         if (flags & NDR_OUT) {
18301                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
18302                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
18303         }
18304         return NDR_ERR_SUCCESS;
18305 }
18306
18307 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
18308 {
18309         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
18310         ndr->depth++;
18311         if (flags & NDR_SET_VALUES) {
18312                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18313         }
18314         if (flags & NDR_IN) {
18315                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
18316                 ndr->depth++;
18317                 ndr_print_ptr(ndr, "handle", r->in.handle);
18318                 ndr->depth++;
18319                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18320                 ndr->depth--;
18321                 ndr_print_string(ndr, "value_name", r->in.value_name);
18322                 ndr_print_uint32(ndr, "offered", r->in.offered);
18323                 ndr->depth--;
18324         }
18325         if (flags & NDR_OUT) {
18326                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
18327                 ndr->depth++;
18328                 ndr_print_ptr(ndr, "type", r->out.type);
18329                 ndr->depth++;
18330                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
18331                 ndr->depth--;
18332                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
18333                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
18334                 ndr_print_ptr(ndr, "needed", r->out.needed);
18335                 ndr->depth++;
18336                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18337                 ndr->depth--;
18338                 ndr_print_WERROR(ndr, "result", r->out.result);
18339                 ndr->depth--;
18340         }
18341         ndr->depth--;
18342 }
18343
18344 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
18345 {
18346         if (flags & NDR_IN) {
18347                 if (r->in.handle == NULL) {
18348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18349                 }
18350                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
18352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
18354                 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));
18355                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
18356                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
18357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
18358         }
18359         if (flags & NDR_OUT) {
18360                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18361         }
18362         return NDR_ERR_SUCCESS;
18363 }
18364
18365 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
18366 {
18367         if (flags & NDR_IN) {
18368                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
18369         }
18370         if (flags & NDR_OUT) {
18371                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
18372                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
18373         }
18374         return NDR_ERR_SUCCESS;
18375 }
18376
18377 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
18378 {
18379         TALLOC_CTX *_mem_save_handle_0;
18380         if (flags & NDR_IN) {
18381                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18382                         NDR_PULL_ALLOC(ndr, r->in.handle);
18383                 }
18384                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18385                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18386                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18388                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
18389                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
18390                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
18391                         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));
18392                 }
18393                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
18394                 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));
18395                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
18396                 {
18397                         struct ndr_pull *_ndr_data;
18398                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
18399                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
18400                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
18401                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
18402                 }
18403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
18404         }
18405         if (flags & NDR_OUT) {
18406                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18407         }
18408         return NDR_ERR_SUCCESS;
18409 }
18410
18411 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
18412 {
18413         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
18414         ndr->depth++;
18415         if (flags & NDR_SET_VALUES) {
18416                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18417         }
18418         if (flags & NDR_IN) {
18419                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
18420                 ndr->depth++;
18421                 ndr_print_ptr(ndr, "handle", r->in.handle);
18422                 ndr->depth++;
18423                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18424                 ndr->depth--;
18425                 ndr_print_string(ndr, "value_name", r->in.value_name);
18426                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
18427                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
18428                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
18429                 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);
18430                 ndr->depth--;
18431         }
18432         if (flags & NDR_OUT) {
18433                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
18434                 ndr->depth++;
18435                 ndr_print_WERROR(ndr, "result", r->out.result);
18436                 ndr->depth--;
18437         }
18438         ndr->depth--;
18439 }
18440
18441 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
18442 {
18443         if (flags & NDR_IN) {
18444         }
18445         if (flags & NDR_OUT) {
18446                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18447         }
18448         return NDR_ERR_SUCCESS;
18449 }
18450
18451 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
18452 {
18453         if (flags & NDR_IN) {
18454         }
18455         if (flags & NDR_OUT) {
18456                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18457         }
18458         return NDR_ERR_SUCCESS;
18459 }
18460
18461 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
18462 {
18463         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
18464         ndr->depth++;
18465         if (flags & NDR_SET_VALUES) {
18466                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18467         }
18468         if (flags & NDR_IN) {
18469                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
18470                 ndr->depth++;
18471                 ndr->depth--;
18472         }
18473         if (flags & NDR_OUT) {
18474                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
18475                 ndr->depth++;
18476                 ndr_print_WERROR(ndr, "result", r->out.result);
18477                 ndr->depth--;
18478         }
18479         ndr->depth--;
18480 }
18481
18482 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
18483 {
18484         if (flags & NDR_IN) {
18485                 if (r->in.handle == NULL) {
18486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18487                 }
18488                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18489         }
18490         if (flags & NDR_OUT) {
18491                 if (r->out.handle == NULL) {
18492                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18493                 }
18494                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18495                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18496         }
18497         return NDR_ERR_SUCCESS;
18498 }
18499
18500 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
18501 {
18502         TALLOC_CTX *_mem_save_handle_0;
18503         if (flags & NDR_IN) {
18504                 ZERO_STRUCT(r->out);
18505
18506                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18507                         NDR_PULL_ALLOC(ndr, r->in.handle);
18508                 }
18509                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18510                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18511                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18513                 NDR_PULL_ALLOC(ndr, r->out.handle);
18514                 *r->out.handle = *r->in.handle;
18515         }
18516         if (flags & NDR_OUT) {
18517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18518                         NDR_PULL_ALLOC(ndr, r->out.handle);
18519                 }
18520                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18521                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18522                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18524                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18525         }
18526         return NDR_ERR_SUCCESS;
18527 }
18528
18529 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
18530 {
18531         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
18532         ndr->depth++;
18533         if (flags & NDR_SET_VALUES) {
18534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18535         }
18536         if (flags & NDR_IN) {
18537                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
18538                 ndr->depth++;
18539                 ndr_print_ptr(ndr, "handle", r->in.handle);
18540                 ndr->depth++;
18541                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18542                 ndr->depth--;
18543                 ndr->depth--;
18544         }
18545         if (flags & NDR_OUT) {
18546                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
18547                 ndr->depth++;
18548                 ndr_print_ptr(ndr, "handle", r->out.handle);
18549                 ndr->depth++;
18550                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18551                 ndr->depth--;
18552                 ndr_print_WERROR(ndr, "result", r->out.result);
18553                 ndr->depth--;
18554         }
18555         ndr->depth--;
18556 }
18557
18558 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
18559 {
18560         if (flags & NDR_IN) {
18561                 if (r->in.handle == NULL) {
18562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18563                 }
18564                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18566                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18567                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18568         }
18569         if (flags & NDR_OUT) {
18570                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18571         }
18572         return NDR_ERR_SUCCESS;
18573 }
18574
18575 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
18576 {
18577         TALLOC_CTX *_mem_save_handle_0;
18578         if (flags & NDR_IN) {
18579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18580                         NDR_PULL_ALLOC(ndr, r->in.handle);
18581                 }
18582                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18584                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18587                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18588                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18589         }
18590         if (flags & NDR_OUT) {
18591                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18592         }
18593         return NDR_ERR_SUCCESS;
18594 }
18595
18596 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
18597 {
18598         ndr_print_struct(ndr, name, "spoolss_AddForm");
18599         ndr->depth++;
18600         if (flags & NDR_SET_VALUES) {
18601                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18602         }
18603         if (flags & NDR_IN) {
18604                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
18605                 ndr->depth++;
18606                 ndr_print_ptr(ndr, "handle", r->in.handle);
18607                 ndr->depth++;
18608                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18609                 ndr->depth--;
18610                 ndr_print_uint32(ndr, "level", r->in.level);
18611                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18612                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18613                 ndr->depth--;
18614         }
18615         if (flags & NDR_OUT) {
18616                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
18617                 ndr->depth++;
18618                 ndr_print_WERROR(ndr, "result", r->out.result);
18619                 ndr->depth--;
18620         }
18621         ndr->depth--;
18622 }
18623
18624 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
18625 {
18626         if (flags & NDR_IN) {
18627                 if (r->in.handle == NULL) {
18628                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18629                 }
18630                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18634                 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));
18635         }
18636         if (flags & NDR_OUT) {
18637                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18638         }
18639         return NDR_ERR_SUCCESS;
18640 }
18641
18642 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
18643 {
18644         TALLOC_CTX *_mem_save_handle_0;
18645         if (flags & NDR_IN) {
18646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18647                         NDR_PULL_ALLOC(ndr, r->in.handle);
18648                 }
18649                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18650                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18651                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18653                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18654                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18655                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18656                         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));
18657                 }
18658                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18659                 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));
18660         }
18661         if (flags & NDR_OUT) {
18662                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18663         }
18664         return NDR_ERR_SUCCESS;
18665 }
18666
18667 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
18668 {
18669         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
18670         ndr->depth++;
18671         if (flags & NDR_SET_VALUES) {
18672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18673         }
18674         if (flags & NDR_IN) {
18675                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
18676                 ndr->depth++;
18677                 ndr_print_ptr(ndr, "handle", r->in.handle);
18678                 ndr->depth++;
18679                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18680                 ndr->depth--;
18681                 ndr_print_string(ndr, "form_name", r->in.form_name);
18682                 ndr->depth--;
18683         }
18684         if (flags & NDR_OUT) {
18685                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
18686                 ndr->depth++;
18687                 ndr_print_WERROR(ndr, "result", r->out.result);
18688                 ndr->depth--;
18689         }
18690         ndr->depth--;
18691 }
18692
18693 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
18694 {
18695         if (flags & NDR_IN) {
18696                 if (r->in.handle == NULL) {
18697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18698                 }
18699                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18703                 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));
18704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18706                 if (r->in.buffer) {
18707                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18708                 }
18709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18710         }
18711         if (flags & NDR_OUT) {
18712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18713                 if (r->out.info) {
18714                         {
18715                                 struct ndr_push *_ndr_info;
18716                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18717                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18718                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18719                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18720                         }
18721                 }
18722                 if (r->out.needed == NULL) {
18723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18724                 }
18725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18726                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18727         }
18728         return NDR_ERR_SUCCESS;
18729 }
18730
18731 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
18732 {
18733         uint32_t _ptr_buffer;
18734         uint32_t _ptr_info;
18735         TALLOC_CTX *_mem_save_handle_0;
18736         TALLOC_CTX *_mem_save_buffer_0;
18737         TALLOC_CTX *_mem_save_info_0;
18738         TALLOC_CTX *_mem_save_needed_0;
18739         if (flags & NDR_IN) {
18740                 ZERO_STRUCT(r->out);
18741
18742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18743                         NDR_PULL_ALLOC(ndr, r->in.handle);
18744                 }
18745                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18746                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18747                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18749                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18750                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18751                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18752                         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));
18753                 }
18754                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18755                 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));
18756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18758                 if (_ptr_buffer) {
18759                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18760                 } else {
18761                         r->in.buffer = NULL;
18762                 }
18763                 if (r->in.buffer) {
18764                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18765                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18766                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18768                 }
18769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18770                 NDR_PULL_ALLOC(ndr, r->out.needed);
18771                 ZERO_STRUCTP(r->out.needed);
18772         }
18773         if (flags & NDR_OUT) {
18774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18775                 if (_ptr_info) {
18776                         NDR_PULL_ALLOC(ndr, r->out.info);
18777                 } else {
18778                         r->out.info = NULL;
18779                 }
18780                 if (r->out.info) {
18781                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18782                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18783                         {
18784                                 struct ndr_pull *_ndr_info;
18785                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18786                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18787                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18788                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18789                         }
18790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18791                 }
18792                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18793                         NDR_PULL_ALLOC(ndr, r->out.needed);
18794                 }
18795                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18796                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18798                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18799                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18800         }
18801         return NDR_ERR_SUCCESS;
18802 }
18803
18804 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
18805 {
18806         ndr_print_struct(ndr, name, "spoolss_GetForm");
18807         ndr->depth++;
18808         if (flags & NDR_SET_VALUES) {
18809                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18810         }
18811         if (flags & NDR_IN) {
18812                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
18813                 ndr->depth++;
18814                 ndr_print_ptr(ndr, "handle", r->in.handle);
18815                 ndr->depth++;
18816                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18817                 ndr->depth--;
18818                 ndr_print_string(ndr, "form_name", r->in.form_name);
18819                 ndr_print_uint32(ndr, "level", r->in.level);
18820                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18821                 ndr->depth++;
18822                 if (r->in.buffer) {
18823                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18824                 }
18825                 ndr->depth--;
18826                 ndr_print_uint32(ndr, "offered", r->in.offered);
18827                 ndr->depth--;
18828         }
18829         if (flags & NDR_OUT) {
18830                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
18831                 ndr->depth++;
18832                 ndr_print_ptr(ndr, "info", r->out.info);
18833                 ndr->depth++;
18834                 if (r->out.info) {
18835                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18836                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
18837                 }
18838                 ndr->depth--;
18839                 ndr_print_ptr(ndr, "needed", r->out.needed);
18840                 ndr->depth++;
18841                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18842                 ndr->depth--;
18843                 ndr_print_WERROR(ndr, "result", r->out.result);
18844                 ndr->depth--;
18845         }
18846         ndr->depth--;
18847 }
18848
18849 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
18850 {
18851         if (flags & NDR_IN) {
18852                 if (r->in.handle == NULL) {
18853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18854                 }
18855                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18859                 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));
18860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18861                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18862                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18863         }
18864         if (flags & NDR_OUT) {
18865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18866         }
18867         return NDR_ERR_SUCCESS;
18868 }
18869
18870 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
18871 {
18872         TALLOC_CTX *_mem_save_handle_0;
18873         if (flags & NDR_IN) {
18874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18875                         NDR_PULL_ALLOC(ndr, r->in.handle);
18876                 }
18877                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18879                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18881                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18882                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18883                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18884                         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));
18885                 }
18886                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18887                 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));
18888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18889                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18890                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18891         }
18892         if (flags & NDR_OUT) {
18893                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18894         }
18895         return NDR_ERR_SUCCESS;
18896 }
18897
18898 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
18899 {
18900         ndr_print_struct(ndr, name, "spoolss_SetForm");
18901         ndr->depth++;
18902         if (flags & NDR_SET_VALUES) {
18903                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18904         }
18905         if (flags & NDR_IN) {
18906                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
18907                 ndr->depth++;
18908                 ndr_print_ptr(ndr, "handle", r->in.handle);
18909                 ndr->depth++;
18910                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18911                 ndr->depth--;
18912                 ndr_print_string(ndr, "form_name", r->in.form_name);
18913                 ndr_print_uint32(ndr, "level", r->in.level);
18914                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18915                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18916                 ndr->depth--;
18917         }
18918         if (flags & NDR_OUT) {
18919                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
18920                 ndr->depth++;
18921                 ndr_print_WERROR(ndr, "result", r->out.result);
18922                 ndr->depth--;
18923         }
18924         ndr->depth--;
18925 }
18926
18927 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
18928 {
18929         if (flags & NDR_IN) {
18930                 if (r->in.handle == NULL) {
18931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18932                 }
18933                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18936                 if (r->in.buffer) {
18937                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18938                 }
18939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18940         }
18941         if (flags & NDR_OUT) {
18942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18943                 if (r->out.info) {
18944                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18945                 }
18946                 if (r->out.needed == NULL) {
18947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18948                 }
18949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18950                 if (r->out.count == NULL) {
18951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18952                 }
18953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18954                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18955         }
18956         return NDR_ERR_SUCCESS;
18957 }
18958
18959 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
18960 {
18961         uint32_t _ptr_buffer;
18962         uint32_t _ptr_info;
18963         TALLOC_CTX *_mem_save_handle_0;
18964         TALLOC_CTX *_mem_save_buffer_0;
18965         TALLOC_CTX *_mem_save_info_0;
18966         TALLOC_CTX *_mem_save_needed_0;
18967         TALLOC_CTX *_mem_save_count_0;
18968         if (flags & NDR_IN) {
18969                 ZERO_STRUCT(r->out);
18970
18971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18972                         NDR_PULL_ALLOC(ndr, r->in.handle);
18973                 }
18974                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18975                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18976                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18977                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18980                 if (_ptr_buffer) {
18981                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18982                 } else {
18983                         r->in.buffer = NULL;
18984                 }
18985                 if (r->in.buffer) {
18986                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18987                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18988                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18990                 }
18991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18992                 NDR_PULL_ALLOC(ndr, r->out.needed);
18993                 ZERO_STRUCTP(r->out.needed);
18994                 NDR_PULL_ALLOC(ndr, r->out.count);
18995                 ZERO_STRUCTP(r->out.count);
18996         }
18997         if (flags & NDR_OUT) {
18998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18999                 if (_ptr_info) {
19000                         NDR_PULL_ALLOC(ndr, r->out.info);
19001                 } else {
19002                         r->out.info = NULL;
19003                 }
19004                 if (r->out.info) {
19005                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19006                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19007                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19009                 }
19010                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19011                         NDR_PULL_ALLOC(ndr, r->out.needed);
19012                 }
19013                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19014                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19018                         NDR_PULL_ALLOC(ndr, r->out.count);
19019                 }
19020                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19021                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19024                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19025         }
19026         return NDR_ERR_SUCCESS;
19027 }
19028
19029 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
19030 {
19031         uint32_t cntr_info_0;
19032         if (flags & NDR_IN) {
19033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19035         }
19036         if (flags & NDR_OUT) {
19037                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19038                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19039                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19040                 }
19041                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19042                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19043                 }
19044         }
19045         return NDR_ERR_SUCCESS;
19046 }
19047
19048 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
19049 {
19050         uint32_t cntr_info_0;
19051         TALLOC_CTX *_mem_save_info_0;
19052         if (flags & NDR_IN) {
19053                 ZERO_STRUCT(r->out);
19054
19055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19057         }
19058         if (flags & NDR_OUT) {
19059                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19060                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19062                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19063                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19064                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19065                 }
19066                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19067                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19068                 }
19069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19070         }
19071         return NDR_ERR_SUCCESS;
19072 }
19073
19074 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
19075 {
19076         uint32_t cntr_info_1;
19077         ndr_print_struct(ndr, name, "spoolss_EnumForms");
19078         ndr->depth++;
19079         if (flags & NDR_SET_VALUES) {
19080                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19081         }
19082         if (flags & NDR_IN) {
19083                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
19084                 ndr->depth++;
19085                 ndr_print_ptr(ndr, "handle", r->in.handle);
19086                 ndr->depth++;
19087                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19088                 ndr->depth--;
19089                 ndr_print_uint32(ndr, "level", r->in.level);
19090                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19091                 ndr->depth++;
19092                 if (r->in.buffer) {
19093                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19094                 }
19095                 ndr->depth--;
19096                 ndr_print_uint32(ndr, "offered", r->in.offered);
19097                 ndr->depth--;
19098         }
19099         if (flags & NDR_OUT) {
19100                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
19101                 ndr->depth++;
19102                 ndr_print_ptr(ndr, "count", r->out.count);
19103                 ndr->depth++;
19104                 ndr_print_uint32(ndr, "count", *r->out.count);
19105                 ndr->depth--;
19106                 ndr_print_ptr(ndr, "info", r->out.info);
19107                 ndr->depth++;
19108                 if (r->out.info) {
19109                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19110                         ndr->depth++;
19111                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19112                                 char *idx_1=NULL;
19113                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19114                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
19115                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
19116                                         free(idx_1);
19117                                 }
19118                         }
19119                         ndr->depth--;
19120                 }
19121                 ndr->depth--;
19122                 ndr_print_ptr(ndr, "needed", r->out.needed);
19123                 ndr->depth++;
19124                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19125                 ndr->depth--;
19126                 ndr_print_WERROR(ndr, "result", r->out.result);
19127                 ndr->depth--;
19128         }
19129         ndr->depth--;
19130 }
19131
19132 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
19133 {
19134         if (flags & NDR_IN) {
19135                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19136                 if (r->in.servername) {
19137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19138                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19141                 }
19142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19143                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19144                 if (r->in.buffer) {
19145                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19146                 }
19147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19148         }
19149         if (flags & NDR_OUT) {
19150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19151                 if (r->out.info) {
19152                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19153                 }
19154                 if (r->out.needed == NULL) {
19155                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19156                 }
19157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19158                 if (r->out.count == NULL) {
19159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19160                 }
19161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19162                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19163         }
19164         return NDR_ERR_SUCCESS;
19165 }
19166
19167 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
19168 {
19169         uint32_t _ptr_servername;
19170         uint32_t _ptr_buffer;
19171         uint32_t _ptr_info;
19172         TALLOC_CTX *_mem_save_servername_0;
19173         TALLOC_CTX *_mem_save_buffer_0;
19174         TALLOC_CTX *_mem_save_info_0;
19175         TALLOC_CTX *_mem_save_needed_0;
19176         TALLOC_CTX *_mem_save_count_0;
19177         if (flags & NDR_IN) {
19178                 ZERO_STRUCT(r->out);
19179
19180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19181                 if (_ptr_servername) {
19182                         NDR_PULL_ALLOC(ndr, r->in.servername);
19183                 } else {
19184                         r->in.servername = NULL;
19185                 }
19186                 if (r->in.servername) {
19187                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19188                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19191                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19192                                 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));
19193                         }
19194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19197                 }
19198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19200                 if (_ptr_buffer) {
19201                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19202                 } else {
19203                         r->in.buffer = NULL;
19204                 }
19205                 if (r->in.buffer) {
19206                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19207                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19208                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19210                 }
19211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19212                 NDR_PULL_ALLOC(ndr, r->out.needed);
19213                 ZERO_STRUCTP(r->out.needed);
19214                 NDR_PULL_ALLOC(ndr, r->out.count);
19215                 ZERO_STRUCTP(r->out.count);
19216         }
19217         if (flags & NDR_OUT) {
19218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19219                 if (_ptr_info) {
19220                         NDR_PULL_ALLOC(ndr, r->out.info);
19221                 } else {
19222                         r->out.info = NULL;
19223                 }
19224                 if (r->out.info) {
19225                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19226                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19227                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19229                 }
19230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19231                         NDR_PULL_ALLOC(ndr, r->out.needed);
19232                 }
19233                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19234                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19237                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19238                         NDR_PULL_ALLOC(ndr, r->out.count);
19239                 }
19240                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19241                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19243                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19244                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19245         }
19246         return NDR_ERR_SUCCESS;
19247 }
19248
19249 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
19250 {
19251         uint32_t cntr_info_0;
19252         if (flags & NDR_IN) {
19253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19255         }
19256         if (flags & NDR_OUT) {
19257                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19258                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19259                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19260                 }
19261                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19262                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19263                 }
19264         }
19265         return NDR_ERR_SUCCESS;
19266 }
19267
19268 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
19269 {
19270         uint32_t cntr_info_0;
19271         TALLOC_CTX *_mem_save_info_0;
19272         if (flags & NDR_IN) {
19273                 ZERO_STRUCT(r->out);
19274
19275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19277         }
19278         if (flags & NDR_OUT) {
19279                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19280                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19281                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19282                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19283                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19284                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19285                 }
19286                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19287                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19288                 }
19289                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19290         }
19291         return NDR_ERR_SUCCESS;
19292 }
19293
19294 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
19295 {
19296         uint32_t cntr_info_1;
19297         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
19298         ndr->depth++;
19299         if (flags & NDR_SET_VALUES) {
19300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19301         }
19302         if (flags & NDR_IN) {
19303                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
19304                 ndr->depth++;
19305                 ndr_print_ptr(ndr, "servername", r->in.servername);
19306                 ndr->depth++;
19307                 if (r->in.servername) {
19308                         ndr_print_string(ndr, "servername", r->in.servername);
19309                 }
19310                 ndr->depth--;
19311                 ndr_print_uint32(ndr, "level", r->in.level);
19312                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19313                 ndr->depth++;
19314                 if (r->in.buffer) {
19315                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19316                 }
19317                 ndr->depth--;
19318                 ndr_print_uint32(ndr, "offered", r->in.offered);
19319                 ndr->depth--;
19320         }
19321         if (flags & NDR_OUT) {
19322                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
19323                 ndr->depth++;
19324                 ndr_print_ptr(ndr, "count", r->out.count);
19325                 ndr->depth++;
19326                 ndr_print_uint32(ndr, "count", *r->out.count);
19327                 ndr->depth--;
19328                 ndr_print_ptr(ndr, "info", r->out.info);
19329                 ndr->depth++;
19330                 if (r->out.info) {
19331                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19332                         ndr->depth++;
19333                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19334                                 char *idx_1=NULL;
19335                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19336                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
19337                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
19338                                         free(idx_1);
19339                                 }
19340                         }
19341                         ndr->depth--;
19342                 }
19343                 ndr->depth--;
19344                 ndr_print_ptr(ndr, "needed", r->out.needed);
19345                 ndr->depth++;
19346                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19347                 ndr->depth--;
19348                 ndr_print_WERROR(ndr, "result", r->out.result);
19349                 ndr->depth--;
19350         }
19351         ndr->depth--;
19352 }
19353
19354 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
19355 {
19356         if (flags & NDR_IN) {
19357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19358                 if (r->in.servername) {
19359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19363                 }
19364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19366                 if (r->in.buffer) {
19367                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19368                 }
19369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19370         }
19371         if (flags & NDR_OUT) {
19372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19373                 if (r->out.info) {
19374                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19375                 }
19376                 if (r->out.needed == NULL) {
19377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19378                 }
19379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19380                 if (r->out.count == NULL) {
19381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19382                 }
19383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19384                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19385         }
19386         return NDR_ERR_SUCCESS;
19387 }
19388
19389 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
19390 {
19391         uint32_t _ptr_servername;
19392         uint32_t _ptr_buffer;
19393         uint32_t _ptr_info;
19394         TALLOC_CTX *_mem_save_servername_0;
19395         TALLOC_CTX *_mem_save_buffer_0;
19396         TALLOC_CTX *_mem_save_info_0;
19397         TALLOC_CTX *_mem_save_needed_0;
19398         TALLOC_CTX *_mem_save_count_0;
19399         if (flags & NDR_IN) {
19400                 ZERO_STRUCT(r->out);
19401
19402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19403                 if (_ptr_servername) {
19404                         NDR_PULL_ALLOC(ndr, r->in.servername);
19405                 } else {
19406                         r->in.servername = NULL;
19407                 }
19408                 if (r->in.servername) {
19409                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19410                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19411                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19412                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19413                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19414                                 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));
19415                         }
19416                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19417                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19418                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19419                 }
19420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19422                 if (_ptr_buffer) {
19423                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19424                 } else {
19425                         r->in.buffer = NULL;
19426                 }
19427                 if (r->in.buffer) {
19428                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19429                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19430                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19432                 }
19433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19434                 NDR_PULL_ALLOC(ndr, r->out.needed);
19435                 ZERO_STRUCTP(r->out.needed);
19436                 NDR_PULL_ALLOC(ndr, r->out.count);
19437                 ZERO_STRUCTP(r->out.count);
19438         }
19439         if (flags & NDR_OUT) {
19440                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19441                 if (_ptr_info) {
19442                         NDR_PULL_ALLOC(ndr, r->out.info);
19443                 } else {
19444                         r->out.info = NULL;
19445                 }
19446                 if (r->out.info) {
19447                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19448                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19449                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19451                 }
19452                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19453                         NDR_PULL_ALLOC(ndr, r->out.needed);
19454                 }
19455                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19456                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19460                         NDR_PULL_ALLOC(ndr, r->out.count);
19461                 }
19462                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19463                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19465                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19466                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19467         }
19468         return NDR_ERR_SUCCESS;
19469 }
19470
19471 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
19472 {
19473         uint32_t cntr_info_0;
19474         if (flags & NDR_IN) {
19475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19477         }
19478         if (flags & NDR_OUT) {
19479                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19480                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19481                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19482                 }
19483                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19484                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19485                 }
19486         }
19487         return NDR_ERR_SUCCESS;
19488 }
19489
19490 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
19491 {
19492         uint32_t cntr_info_0;
19493         TALLOC_CTX *_mem_save_info_0;
19494         if (flags & NDR_IN) {
19495                 ZERO_STRUCT(r->out);
19496
19497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19499         }
19500         if (flags & NDR_OUT) {
19501                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19502                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19503                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19504                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19505                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19506                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19507                 }
19508                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19509                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19510                 }
19511                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19512         }
19513         return NDR_ERR_SUCCESS;
19514 }
19515
19516 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
19517 {
19518         uint32_t cntr_info_1;
19519         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
19520         ndr->depth++;
19521         if (flags & NDR_SET_VALUES) {
19522                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19523         }
19524         if (flags & NDR_IN) {
19525                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
19526                 ndr->depth++;
19527                 ndr_print_ptr(ndr, "servername", r->in.servername);
19528                 ndr->depth++;
19529                 if (r->in.servername) {
19530                         ndr_print_string(ndr, "servername", r->in.servername);
19531                 }
19532                 ndr->depth--;
19533                 ndr_print_uint32(ndr, "level", r->in.level);
19534                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19535                 ndr->depth++;
19536                 if (r->in.buffer) {
19537                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19538                 }
19539                 ndr->depth--;
19540                 ndr_print_uint32(ndr, "offered", r->in.offered);
19541                 ndr->depth--;
19542         }
19543         if (flags & NDR_OUT) {
19544                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
19545                 ndr->depth++;
19546                 ndr_print_ptr(ndr, "count", r->out.count);
19547                 ndr->depth++;
19548                 ndr_print_uint32(ndr, "count", *r->out.count);
19549                 ndr->depth--;
19550                 ndr_print_ptr(ndr, "info", r->out.info);
19551                 ndr->depth++;
19552                 if (r->out.info) {
19553                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19554                         ndr->depth++;
19555                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19556                                 char *idx_1=NULL;
19557                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19558                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
19559                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
19560                                         free(idx_1);
19561                                 }
19562                         }
19563                         ndr->depth--;
19564                 }
19565                 ndr->depth--;
19566                 ndr_print_ptr(ndr, "needed", r->out.needed);
19567                 ndr->depth++;
19568                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19569                 ndr->depth--;
19570                 ndr_print_WERROR(ndr, "result", r->out.result);
19571                 ndr->depth--;
19572         }
19573         ndr->depth--;
19574 }
19575
19576 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
19577 {
19578         if (flags & NDR_IN) {
19579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
19580                 if (r->in.server_name) {
19581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19582                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19583                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19584                         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));
19585                 }
19586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
19587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19590                 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));
19591         }
19592         if (flags & NDR_OUT) {
19593                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19594         }
19595         return NDR_ERR_SUCCESS;
19596 }
19597
19598 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
19599 {
19600         uint32_t _ptr_server_name;
19601         TALLOC_CTX *_mem_save_server_name_0;
19602         if (flags & NDR_IN) {
19603                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
19604                 if (_ptr_server_name) {
19605                         NDR_PULL_ALLOC(ndr, r->in.server_name);
19606                 } else {
19607                         r->in.server_name = NULL;
19608                 }
19609                 if (r->in.server_name) {
19610                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19611                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
19612                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
19613                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
19614                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
19615                                 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));
19616                         }
19617                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
19618                         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));
19619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
19620                 }
19621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
19622                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
19623                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
19624                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
19625                         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));
19626                 }
19627                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
19628                 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));
19629         }
19630         if (flags & NDR_OUT) {
19631                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19632         }
19633         return NDR_ERR_SUCCESS;
19634 }
19635
19636 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
19637 {
19638         ndr_print_struct(ndr, name, "spoolss_AddPort");
19639         ndr->depth++;
19640         if (flags & NDR_SET_VALUES) {
19641                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19642         }
19643         if (flags & NDR_IN) {
19644                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
19645                 ndr->depth++;
19646                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
19647                 ndr->depth++;
19648                 if (r->in.server_name) {
19649                         ndr_print_string(ndr, "server_name", r->in.server_name);
19650                 }
19651                 ndr->depth--;
19652                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
19653                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
19654                 ndr->depth--;
19655         }
19656         if (flags & NDR_OUT) {
19657                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
19658                 ndr->depth++;
19659                 ndr_print_WERROR(ndr, "result", r->out.result);
19660                 ndr->depth--;
19661         }
19662         ndr->depth--;
19663 }
19664
19665 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
19666 {
19667         if (flags & NDR_IN) {
19668         }
19669         if (flags & NDR_OUT) {
19670                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19671         }
19672         return NDR_ERR_SUCCESS;
19673 }
19674
19675 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
19676 {
19677         if (flags & NDR_IN) {
19678         }
19679         if (flags & NDR_OUT) {
19680                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19681         }
19682         return NDR_ERR_SUCCESS;
19683 }
19684
19685 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
19686 {
19687         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
19688         ndr->depth++;
19689         if (flags & NDR_SET_VALUES) {
19690                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19691         }
19692         if (flags & NDR_IN) {
19693                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
19694                 ndr->depth++;
19695                 ndr->depth--;
19696         }
19697         if (flags & NDR_OUT) {
19698                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
19699                 ndr->depth++;
19700                 ndr_print_WERROR(ndr, "result", r->out.result);
19701                 ndr->depth--;
19702         }
19703         ndr->depth--;
19704 }
19705
19706 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
19707 {
19708         if (flags & NDR_IN) {
19709         }
19710         if (flags & NDR_OUT) {
19711                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19712         }
19713         return NDR_ERR_SUCCESS;
19714 }
19715
19716 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
19717 {
19718         if (flags & NDR_IN) {
19719         }
19720         if (flags & NDR_OUT) {
19721                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19722         }
19723         return NDR_ERR_SUCCESS;
19724 }
19725
19726 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
19727 {
19728         ndr_print_struct(ndr, name, "spoolss_DeletePort");
19729         ndr->depth++;
19730         if (flags & NDR_SET_VALUES) {
19731                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19732         }
19733         if (flags & NDR_IN) {
19734                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
19735                 ndr->depth++;
19736                 ndr->depth--;
19737         }
19738         if (flags & NDR_OUT) {
19739                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
19740                 ndr->depth++;
19741                 ndr_print_WERROR(ndr, "result", r->out.result);
19742                 ndr->depth--;
19743         }
19744         ndr->depth--;
19745 }
19746
19747 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
19748 {
19749         if (flags & NDR_IN) {
19750         }
19751         if (flags & NDR_OUT) {
19752                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19753         }
19754         return NDR_ERR_SUCCESS;
19755 }
19756
19757 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
19758 {
19759         if (flags & NDR_IN) {
19760         }
19761         if (flags & NDR_OUT) {
19762                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19763         }
19764         return NDR_ERR_SUCCESS;
19765 }
19766
19767 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
19768 {
19769         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
19770         ndr->depth++;
19771         if (flags & NDR_SET_VALUES) {
19772                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19773         }
19774         if (flags & NDR_IN) {
19775                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
19776                 ndr->depth++;
19777                 ndr->depth--;
19778         }
19779         if (flags & NDR_OUT) {
19780                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
19781                 ndr->depth++;
19782                 ndr_print_WERROR(ndr, "result", r->out.result);
19783                 ndr->depth--;
19784         }
19785         ndr->depth--;
19786 }
19787
19788 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19789 {
19790         if (flags & NDR_IN) {
19791         }
19792         if (flags & NDR_OUT) {
19793                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19794         }
19795         return NDR_ERR_SUCCESS;
19796 }
19797
19798 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
19799 {
19800         if (flags & NDR_IN) {
19801         }
19802         if (flags & NDR_OUT) {
19803                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19804         }
19805         return NDR_ERR_SUCCESS;
19806 }
19807
19808 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19809 {
19810         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
19811         ndr->depth++;
19812         if (flags & NDR_SET_VALUES) {
19813                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19814         }
19815         if (flags & NDR_IN) {
19816                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
19817                 ndr->depth++;
19818                 ndr->depth--;
19819         }
19820         if (flags & NDR_OUT) {
19821                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
19822                 ndr->depth++;
19823                 ndr_print_WERROR(ndr, "result", r->out.result);
19824                 ndr->depth--;
19825         }
19826         ndr->depth--;
19827 }
19828
19829 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
19830 {
19831         if (flags & NDR_IN) {
19832         }
19833         if (flags & NDR_OUT) {
19834                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19835         }
19836         return NDR_ERR_SUCCESS;
19837 }
19838
19839 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
19840 {
19841         if (flags & NDR_IN) {
19842         }
19843         if (flags & NDR_OUT) {
19844                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19845         }
19846         return NDR_ERR_SUCCESS;
19847 }
19848
19849 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
19850 {
19851         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
19852         ndr->depth++;
19853         if (flags & NDR_SET_VALUES) {
19854                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19855         }
19856         if (flags & NDR_IN) {
19857                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
19858                 ndr->depth++;
19859                 ndr->depth--;
19860         }
19861         if (flags & NDR_OUT) {
19862                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
19863                 ndr->depth++;
19864                 ndr_print_WERROR(ndr, "result", r->out.result);
19865                 ndr->depth--;
19866         }
19867         ndr->depth--;
19868 }
19869
19870 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
19871 {
19872         if (flags & NDR_IN) {
19873         }
19874         if (flags & NDR_OUT) {
19875                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19876         }
19877         return NDR_ERR_SUCCESS;
19878 }
19879
19880 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
19881 {
19882         if (flags & NDR_IN) {
19883         }
19884         if (flags & NDR_OUT) {
19885                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19886         }
19887         return NDR_ERR_SUCCESS;
19888 }
19889
19890 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
19891 {
19892         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
19893         ndr->depth++;
19894         if (flags & NDR_SET_VALUES) {
19895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19896         }
19897         if (flags & NDR_IN) {
19898                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
19899                 ndr->depth++;
19900                 ndr->depth--;
19901         }
19902         if (flags & NDR_OUT) {
19903                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
19904                 ndr->depth++;
19905                 ndr_print_WERROR(ndr, "result", r->out.result);
19906                 ndr->depth--;
19907         }
19908         ndr->depth--;
19909 }
19910
19911 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
19912 {
19913         if (flags & NDR_IN) {
19914         }
19915         if (flags & NDR_OUT) {
19916                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19917         }
19918         return NDR_ERR_SUCCESS;
19919 }
19920
19921 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
19922 {
19923         if (flags & NDR_IN) {
19924         }
19925         if (flags & NDR_OUT) {
19926                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19927         }
19928         return NDR_ERR_SUCCESS;
19929 }
19930
19931 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
19932 {
19933         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
19934         ndr->depth++;
19935         if (flags & NDR_SET_VALUES) {
19936                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19937         }
19938         if (flags & NDR_IN) {
19939                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
19940                 ndr->depth++;
19941                 ndr->depth--;
19942         }
19943         if (flags & NDR_OUT) {
19944                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
19945                 ndr->depth++;
19946                 ndr_print_WERROR(ndr, "result", r->out.result);
19947                 ndr->depth--;
19948         }
19949         ndr->depth--;
19950 }
19951
19952 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
19953 {
19954         if (flags & NDR_IN) {
19955         }
19956         if (flags & NDR_OUT) {
19957                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19958         }
19959         return NDR_ERR_SUCCESS;
19960 }
19961
19962 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
19963 {
19964         if (flags & NDR_IN) {
19965         }
19966         if (flags & NDR_OUT) {
19967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19968         }
19969         return NDR_ERR_SUCCESS;
19970 }
19971
19972 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
19973 {
19974         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
19975         ndr->depth++;
19976         if (flags & NDR_SET_VALUES) {
19977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19978         }
19979         if (flags & NDR_IN) {
19980                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
19981                 ndr->depth++;
19982                 ndr->depth--;
19983         }
19984         if (flags & NDR_OUT) {
19985                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
19986                 ndr->depth++;
19987                 ndr_print_WERROR(ndr, "result", r->out.result);
19988                 ndr->depth--;
19989         }
19990         ndr->depth--;
19991 }
19992
19993 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
19994 {
19995         if (flags & NDR_IN) {
19996         }
19997         if (flags & NDR_OUT) {
19998                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19999         }
20000         return NDR_ERR_SUCCESS;
20001 }
20002
20003 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
20004 {
20005         if (flags & NDR_IN) {
20006         }
20007         if (flags & NDR_OUT) {
20008                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20009         }
20010         return NDR_ERR_SUCCESS;
20011 }
20012
20013 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
20014 {
20015         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
20016         ndr->depth++;
20017         if (flags & NDR_SET_VALUES) {
20018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20019         }
20020         if (flags & NDR_IN) {
20021                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
20022                 ndr->depth++;
20023                 ndr->depth--;
20024         }
20025         if (flags & NDR_OUT) {
20026                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
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_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
20035 {
20036         if (flags & NDR_IN) {
20037         }
20038         if (flags & NDR_OUT) {
20039                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20040         }
20041         return NDR_ERR_SUCCESS;
20042 }
20043
20044 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
20045 {
20046         if (flags & NDR_IN) {
20047         }
20048         if (flags & NDR_OUT) {
20049                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20050         }
20051         return NDR_ERR_SUCCESS;
20052 }
20053
20054 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
20055 {
20056         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
20057         ndr->depth++;
20058         if (flags & NDR_SET_VALUES) {
20059                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20060         }
20061         if (flags & NDR_IN) {
20062                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
20063                 ndr->depth++;
20064                 ndr->depth--;
20065         }
20066         if (flags & NDR_OUT) {
20067                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
20068                 ndr->depth++;
20069                 ndr_print_WERROR(ndr, "result", r->out.result);
20070                 ndr->depth--;
20071         }
20072         ndr->depth--;
20073 }
20074
20075 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
20076 {
20077         if (flags & NDR_IN) {
20078         }
20079         if (flags & NDR_OUT) {
20080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20081         }
20082         return NDR_ERR_SUCCESS;
20083 }
20084
20085 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
20086 {
20087         if (flags & NDR_IN) {
20088         }
20089         if (flags & NDR_OUT) {
20090                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20091         }
20092         return NDR_ERR_SUCCESS;
20093 }
20094
20095 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
20096 {
20097         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
20098         ndr->depth++;
20099         if (flags & NDR_SET_VALUES) {
20100                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20101         }
20102         if (flags & NDR_IN) {
20103                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
20104                 ndr->depth++;
20105                 ndr->depth--;
20106         }
20107         if (flags & NDR_OUT) {
20108                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
20109                 ndr->depth++;
20110                 ndr_print_WERROR(ndr, "result", r->out.result);
20111                 ndr->depth--;
20112         }
20113         ndr->depth--;
20114 }
20115
20116 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
20117 {
20118         if (flags & NDR_IN) {
20119         }
20120         if (flags & NDR_OUT) {
20121                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20122         }
20123         return NDR_ERR_SUCCESS;
20124 }
20125
20126 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
20127 {
20128         if (flags & NDR_IN) {
20129         }
20130         if (flags & NDR_OUT) {
20131                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20132         }
20133         return NDR_ERR_SUCCESS;
20134 }
20135
20136 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
20137 {
20138         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
20139         ndr->depth++;
20140         if (flags & NDR_SET_VALUES) {
20141                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20142         }
20143         if (flags & NDR_IN) {
20144                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
20145                 ndr->depth++;
20146                 ndr->depth--;
20147         }
20148         if (flags & NDR_OUT) {
20149                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
20150                 ndr->depth++;
20151                 ndr_print_WERROR(ndr, "result", r->out.result);
20152                 ndr->depth--;
20153         }
20154         ndr->depth--;
20155 }
20156
20157 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
20158 {
20159         if (flags & NDR_IN) {
20160         }
20161         if (flags & NDR_OUT) {
20162                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20163         }
20164         return NDR_ERR_SUCCESS;
20165 }
20166
20167 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
20168 {
20169         if (flags & NDR_IN) {
20170         }
20171         if (flags & NDR_OUT) {
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_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
20178 {
20179         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
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_DeletePrintProvidor");
20186                 ndr->depth++;
20187                 ndr->depth--;
20188         }
20189         if (flags & NDR_OUT) {
20190                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
20191                 ndr->depth++;
20192                 ndr_print_WERROR(ndr, "result", r->out.result);
20193                 ndr->depth--;
20194         }
20195         ndr->depth--;
20196 }
20197
20198 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
20199 {
20200         if (flags & NDR_IN) {
20201         }
20202         if (flags & NDR_OUT) {
20203                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20204         }
20205         return NDR_ERR_SUCCESS;
20206 }
20207
20208 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
20209 {
20210         if (flags & NDR_IN) {
20211         }
20212         if (flags & NDR_OUT) {
20213                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20214         }
20215         return NDR_ERR_SUCCESS;
20216 }
20217
20218 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
20219 {
20220         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
20221         ndr->depth++;
20222         if (flags & NDR_SET_VALUES) {
20223                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20224         }
20225         if (flags & NDR_IN) {
20226                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
20227                 ndr->depth++;
20228                 ndr->depth--;
20229         }
20230         if (flags & NDR_OUT) {
20231                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
20232                 ndr->depth++;
20233                 ndr_print_WERROR(ndr, "result", r->out.result);
20234                 ndr->depth--;
20235         }
20236         ndr->depth--;
20237 }
20238
20239 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
20240 {
20241         if (flags & NDR_IN) {
20242                 if (r->in.handle == NULL) {
20243                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20244                 }
20245                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20246                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
20247                 if (r->in.data_type) {
20248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
20249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
20251                         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));
20252                 }
20253                 if (r->in.devmode_ctr == NULL) {
20254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20255                 }
20256                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20257         }
20258         if (flags & NDR_OUT) {
20259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20260         }
20261         return NDR_ERR_SUCCESS;
20262 }
20263
20264 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
20265 {
20266         uint32_t _ptr_data_type;
20267         TALLOC_CTX *_mem_save_handle_0;
20268         TALLOC_CTX *_mem_save_data_type_0;
20269         TALLOC_CTX *_mem_save_devmode_ctr_0;
20270         if (flags & NDR_IN) {
20271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20272                         NDR_PULL_ALLOC(ndr, r->in.handle);
20273                 }
20274                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20275                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20276                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
20279                 if (_ptr_data_type) {
20280                         NDR_PULL_ALLOC(ndr, r->in.data_type);
20281                 } else {
20282                         r->in.data_type = NULL;
20283                 }
20284                 if (r->in.data_type) {
20285                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
20286                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
20287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
20288                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
20289                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
20290                                 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));
20291                         }
20292                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
20293                         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));
20294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
20295                 }
20296                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20297                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20298                 }
20299                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20300                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20301                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20303         }
20304         if (flags & NDR_OUT) {
20305                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20306         }
20307         return NDR_ERR_SUCCESS;
20308 }
20309
20310 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
20311 {
20312         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
20313         ndr->depth++;
20314         if (flags & NDR_SET_VALUES) {
20315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20316         }
20317         if (flags & NDR_IN) {
20318                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
20319                 ndr->depth++;
20320                 ndr_print_ptr(ndr, "handle", r->in.handle);
20321                 ndr->depth++;
20322                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20323                 ndr->depth--;
20324                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
20325                 ndr->depth++;
20326                 if (r->in.data_type) {
20327                         ndr_print_string(ndr, "data_type", r->in.data_type);
20328                 }
20329                 ndr->depth--;
20330                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20331                 ndr->depth++;
20332                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20333                 ndr->depth--;
20334                 ndr->depth--;
20335         }
20336         if (flags & NDR_OUT) {
20337                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
20338                 ndr->depth++;
20339                 ndr_print_WERROR(ndr, "result", r->out.result);
20340                 ndr->depth--;
20341         }
20342         ndr->depth--;
20343 }
20344
20345 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
20346 {
20347         if (flags & NDR_IN) {
20348                 if (r->in.handle == NULL) {
20349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20350                 }
20351                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
20353                 if (r->in.architecture) {
20354                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20358                 }
20359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20361                 if (r->in.buffer) {
20362                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20363                 }
20364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
20366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
20367         }
20368         if (flags & NDR_OUT) {
20369                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20370                 if (r->out.info) {
20371                         {
20372                                 struct ndr_push *_ndr_info;
20373                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20374                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20375                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20376                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20377                         }
20378                 }
20379                 if (r->out.needed == NULL) {
20380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20381                 }
20382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20383                 if (r->out.server_major_version == NULL) {
20384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20385                 }
20386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
20387                 if (r->out.server_minor_version == NULL) {
20388                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20389                 }
20390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
20391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20392         }
20393         return NDR_ERR_SUCCESS;
20394 }
20395
20396 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
20397 {
20398         uint32_t _ptr_architecture;
20399         uint32_t _ptr_buffer;
20400         uint32_t _ptr_info;
20401         TALLOC_CTX *_mem_save_handle_0;
20402         TALLOC_CTX *_mem_save_architecture_0;
20403         TALLOC_CTX *_mem_save_buffer_0;
20404         TALLOC_CTX *_mem_save_info_0;
20405         TALLOC_CTX *_mem_save_needed_0;
20406         TALLOC_CTX *_mem_save_server_major_version_0;
20407         TALLOC_CTX *_mem_save_server_minor_version_0;
20408         if (flags & NDR_IN) {
20409                 ZERO_STRUCT(r->out);
20410
20411                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20412                         NDR_PULL_ALLOC(ndr, r->in.handle);
20413                 }
20414                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20415                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20416                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
20419                 if (_ptr_architecture) {
20420                         NDR_PULL_ALLOC(ndr, r->in.architecture);
20421                 } else {
20422                         r->in.architecture = NULL;
20423                 }
20424                 if (r->in.architecture) {
20425                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
20426                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
20427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20429                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20430                                 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));
20431                         }
20432                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20433                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
20435                 }
20436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20438                 if (_ptr_buffer) {
20439                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20440                 } else {
20441                         r->in.buffer = NULL;
20442                 }
20443                 if (r->in.buffer) {
20444                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20445                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20446                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20448                 }
20449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
20451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
20452                 NDR_PULL_ALLOC(ndr, r->out.needed);
20453                 ZERO_STRUCTP(r->out.needed);
20454                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
20455                 ZERO_STRUCTP(r->out.server_major_version);
20456                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
20457                 ZERO_STRUCTP(r->out.server_minor_version);
20458         }
20459         if (flags & NDR_OUT) {
20460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20461                 if (_ptr_info) {
20462                         NDR_PULL_ALLOC(ndr, r->out.info);
20463                 } else {
20464                         r->out.info = NULL;
20465                 }
20466                 if (r->out.info) {
20467                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20468                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20469                         {
20470                                 struct ndr_pull *_ndr_info;
20471                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20472                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20473                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20474                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20475                         }
20476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20477                 }
20478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20479                         NDR_PULL_ALLOC(ndr, r->out.needed);
20480                 }
20481                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20482                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20485                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20486                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
20487                 }
20488                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
20489                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
20490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
20491                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
20492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20493                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
20494                 }
20495                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
20496                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
20497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
20498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
20499                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20500         }
20501         return NDR_ERR_SUCCESS;
20502 }
20503
20504 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
20505 {
20506         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
20507         ndr->depth++;
20508         if (flags & NDR_SET_VALUES) {
20509                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20510         }
20511         if (flags & NDR_IN) {
20512                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
20513                 ndr->depth++;
20514                 ndr_print_ptr(ndr, "handle", r->in.handle);
20515                 ndr->depth++;
20516                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20517                 ndr->depth--;
20518                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
20519                 ndr->depth++;
20520                 if (r->in.architecture) {
20521                         ndr_print_string(ndr, "architecture", r->in.architecture);
20522                 }
20523                 ndr->depth--;
20524                 ndr_print_uint32(ndr, "level", r->in.level);
20525                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20526                 ndr->depth++;
20527                 if (r->in.buffer) {
20528                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20529                 }
20530                 ndr->depth--;
20531                 ndr_print_uint32(ndr, "offered", r->in.offered);
20532                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
20533                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
20534                 ndr->depth--;
20535         }
20536         if (flags & NDR_OUT) {
20537                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
20538                 ndr->depth++;
20539                 ndr_print_ptr(ndr, "info", r->out.info);
20540                 ndr->depth++;
20541                 if (r->out.info) {
20542                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20543                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
20544                 }
20545                 ndr->depth--;
20546                 ndr_print_ptr(ndr, "needed", r->out.needed);
20547                 ndr->depth++;
20548                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20549                 ndr->depth--;
20550                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
20551                 ndr->depth++;
20552                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
20553                 ndr->depth--;
20554                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
20555                 ndr->depth++;
20556                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
20557                 ndr->depth--;
20558                 ndr_print_WERROR(ndr, "result", r->out.result);
20559                 ndr->depth--;
20560         }
20561         ndr->depth--;
20562 }
20563
20564 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20565 {
20566         if (flags & NDR_IN) {
20567         }
20568         if (flags & NDR_OUT) {
20569                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20570         }
20571         return NDR_ERR_SUCCESS;
20572 }
20573
20574 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
20575 {
20576         if (flags & NDR_IN) {
20577         }
20578         if (flags & NDR_OUT) {
20579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20580         }
20581         return NDR_ERR_SUCCESS;
20582 }
20583
20584 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20585 {
20586         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
20587         ndr->depth++;
20588         if (flags & NDR_SET_VALUES) {
20589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20590         }
20591         if (flags & NDR_IN) {
20592                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
20593                 ndr->depth++;
20594                 ndr->depth--;
20595         }
20596         if (flags & NDR_OUT) {
20597                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
20598                 ndr->depth++;
20599                 ndr_print_WERROR(ndr, "result", r->out.result);
20600                 ndr->depth--;
20601         }
20602         ndr->depth--;
20603 }
20604
20605 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20606 {
20607         if (flags & NDR_IN) {
20608         }
20609         if (flags & NDR_OUT) {
20610                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20611         }
20612         return NDR_ERR_SUCCESS;
20613 }
20614
20615 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
20616 {
20617         if (flags & NDR_IN) {
20618         }
20619         if (flags & NDR_OUT) {
20620                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20621         }
20622         return NDR_ERR_SUCCESS;
20623 }
20624
20625 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20626 {
20627         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
20628         ndr->depth++;
20629         if (flags & NDR_SET_VALUES) {
20630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20631         }
20632         if (flags & NDR_IN) {
20633                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
20634                 ndr->depth++;
20635                 ndr->depth--;
20636         }
20637         if (flags & NDR_OUT) {
20638                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
20639                 ndr->depth++;
20640                 ndr_print_WERROR(ndr, "result", r->out.result);
20641                 ndr->depth--;
20642         }
20643         ndr->depth--;
20644 }
20645
20646 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
20647 {
20648         if (flags & NDR_IN) {
20649                 if (r->in.handle == NULL) {
20650                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20651                 }
20652                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20653         }
20654         if (flags & NDR_OUT) {
20655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20656         }
20657         return NDR_ERR_SUCCESS;
20658 }
20659
20660 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
20661 {
20662         TALLOC_CTX *_mem_save_handle_0;
20663         if (flags & NDR_IN) {
20664                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20665                         NDR_PULL_ALLOC(ndr, r->in.handle);
20666                 }
20667                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20668                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20669                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20670                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20671         }
20672         if (flags & NDR_OUT) {
20673                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20674         }
20675         return NDR_ERR_SUCCESS;
20676 }
20677
20678 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
20679 {
20680         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
20681         ndr->depth++;
20682         if (flags & NDR_SET_VALUES) {
20683                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20684         }
20685         if (flags & NDR_IN) {
20686                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
20687                 ndr->depth++;
20688                 ndr_print_ptr(ndr, "handle", r->in.handle);
20689                 ndr->depth++;
20690                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20691                 ndr->depth--;
20692                 ndr->depth--;
20693         }
20694         if (flags & NDR_OUT) {
20695                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
20696                 ndr->depth++;
20697                 ndr_print_WERROR(ndr, "result", r->out.result);
20698                 ndr->depth--;
20699         }
20700         ndr->depth--;
20701 }
20702
20703 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20704 {
20705         if (flags & NDR_IN) {
20706         }
20707         if (flags & NDR_OUT) {
20708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20709         }
20710         return NDR_ERR_SUCCESS;
20711 }
20712
20713 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20714 {
20715         if (flags & NDR_IN) {
20716         }
20717         if (flags & NDR_OUT) {
20718                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20719         }
20720         return NDR_ERR_SUCCESS;
20721 }
20722
20723 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20724 {
20725         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20726         ndr->depth++;
20727         if (flags & NDR_SET_VALUES) {
20728                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20729         }
20730         if (flags & NDR_IN) {
20731                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20732                 ndr->depth++;
20733                 ndr->depth--;
20734         }
20735         if (flags & NDR_OUT) {
20736                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20737                 ndr->depth++;
20738                 ndr_print_WERROR(ndr, "result", r->out.result);
20739                 ndr->depth--;
20740         }
20741         ndr->depth--;
20742 }
20743
20744 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
20745 {
20746         if (flags & NDR_IN) {
20747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20750                 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));
20751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20752                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
20753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20755                 if (r->in.buffer) {
20756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20757                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20758                 }
20759         }
20760         if (flags & NDR_OUT) {
20761                 if (r->out.handle == NULL) {
20762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20763                 }
20764                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20765                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20766         }
20767         return NDR_ERR_SUCCESS;
20768 }
20769
20770 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
20771 {
20772         uint32_t _ptr_buffer;
20773         TALLOC_CTX *_mem_save_buffer_0;
20774         TALLOC_CTX *_mem_save_handle_0;
20775         if (flags & NDR_IN) {
20776                 ZERO_STRUCT(r->out);
20777
20778                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
20779                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
20780                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
20781                         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));
20782                 }
20783                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
20784                 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));
20785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20786                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
20787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20788                 if (r->in.bufsize > 512) {
20789                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20790                 }
20791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20792                 if (_ptr_buffer) {
20793                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20794                 } else {
20795                         r->in.buffer = NULL;
20796                 }
20797                 if (r->in.buffer) {
20798                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20801                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20802                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20804                 }
20805                 NDR_PULL_ALLOC(ndr, r->out.handle);
20806                 ZERO_STRUCTP(r->out.handle);
20807                 if (r->in.buffer) {
20808                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20809                 }
20810         }
20811         if (flags & NDR_OUT) {
20812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20813                         NDR_PULL_ALLOC(ndr, r->out.handle);
20814                 }
20815                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20816                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20817                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20818                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20819                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20820         }
20821         return NDR_ERR_SUCCESS;
20822 }
20823
20824 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
20825 {
20826         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
20827         ndr->depth++;
20828         if (flags & NDR_SET_VALUES) {
20829                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20830         }
20831         if (flags & NDR_IN) {
20832                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
20833                 ndr->depth++;
20834                 ndr_print_string(ndr, "server_name", r->in.server_name);
20835                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20836                 ndr_print_winreg_Type(ndr, "type", r->in.type);
20837                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20838                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20839                 ndr->depth++;
20840                 if (r->in.buffer) {
20841                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20842                 }
20843                 ndr->depth--;
20844                 ndr->depth--;
20845         }
20846         if (flags & NDR_OUT) {
20847                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
20848                 ndr->depth++;
20849                 ndr_print_ptr(ndr, "handle", r->out.handle);
20850                 ndr->depth++;
20851                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20852                 ndr->depth--;
20853                 ndr_print_WERROR(ndr, "result", r->out.result);
20854                 ndr->depth--;
20855         }
20856         ndr->depth--;
20857 }
20858
20859 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
20860 {
20861         if (flags & NDR_IN) {
20862                 if (r->in.handle == NULL) {
20863                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20864                 }
20865                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20866                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20869                 if (r->in.buffer) {
20870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20871                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20872                 }
20873         }
20874         if (flags & NDR_OUT) {
20875                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20876         }
20877         return NDR_ERR_SUCCESS;
20878 }
20879
20880 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
20881 {
20882         uint32_t _ptr_buffer;
20883         TALLOC_CTX *_mem_save_handle_0;
20884         TALLOC_CTX *_mem_save_buffer_0;
20885         if (flags & NDR_IN) {
20886                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20887                         NDR_PULL_ALLOC(ndr, r->in.handle);
20888                 }
20889                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20890                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20891                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20893                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20895                 if (r->in.bufsize > 512) {
20896                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20897                 }
20898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20899                 if (_ptr_buffer) {
20900                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20901                 } else {
20902                         r->in.buffer = NULL;
20903                 }
20904                 if (r->in.buffer) {
20905                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20906                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20908                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20909                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20910                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20911                 }
20912                 if (r->in.buffer) {
20913                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20914                 }
20915         }
20916         if (flags & NDR_OUT) {
20917                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20918         }
20919         return NDR_ERR_SUCCESS;
20920 }
20921
20922 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
20923 {
20924         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
20925         ndr->depth++;
20926         if (flags & NDR_SET_VALUES) {
20927                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20928         }
20929         if (flags & NDR_IN) {
20930                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
20931                 ndr->depth++;
20932                 ndr_print_ptr(ndr, "handle", r->in.handle);
20933                 ndr->depth++;
20934                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20935                 ndr->depth--;
20936                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20937                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20938                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20939                 ndr->depth++;
20940                 if (r->in.buffer) {
20941                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20942                 }
20943                 ndr->depth--;
20944                 ndr->depth--;
20945         }
20946         if (flags & NDR_OUT) {
20947                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
20948                 ndr->depth++;
20949                 ndr_print_WERROR(ndr, "result", r->out.result);
20950                 ndr->depth--;
20951         }
20952         ndr->depth--;
20953 }
20954
20955 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
20956 {
20957         if (flags & NDR_IN) {
20958                 if (r->in.handle == NULL) {
20959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20960                 }
20961                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20962         }
20963         if (flags & NDR_OUT) {
20964                 if (r->out.handle == NULL) {
20965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20966                 }
20967                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20968                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20969         }
20970         return NDR_ERR_SUCCESS;
20971 }
20972
20973 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
20974 {
20975         TALLOC_CTX *_mem_save_handle_0;
20976         if (flags & NDR_IN) {
20977                 ZERO_STRUCT(r->out);
20978
20979                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20980                         NDR_PULL_ALLOC(ndr, r->in.handle);
20981                 }
20982                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20983                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20984                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20986                 NDR_PULL_ALLOC(ndr, r->out.handle);
20987                 *r->out.handle = *r->in.handle;
20988         }
20989         if (flags & NDR_OUT) {
20990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20991                         NDR_PULL_ALLOC(ndr, r->out.handle);
20992                 }
20993                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20995                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20996                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20997                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20998         }
20999         return NDR_ERR_SUCCESS;
21000 }
21001
21002 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
21003 {
21004         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
21005         ndr->depth++;
21006         if (flags & NDR_SET_VALUES) {
21007                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21008         }
21009         if (flags & NDR_IN) {
21010                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
21011                 ndr->depth++;
21012                 ndr_print_ptr(ndr, "handle", r->in.handle);
21013                 ndr->depth++;
21014                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21015                 ndr->depth--;
21016                 ndr->depth--;
21017         }
21018         if (flags & NDR_OUT) {
21019                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
21020                 ndr->depth++;
21021                 ndr_print_ptr(ndr, "handle", r->out.handle);
21022                 ndr->depth++;
21023                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21024                 ndr->depth--;
21025                 ndr_print_WERROR(ndr, "result", r->out.result);
21026                 ndr->depth--;
21027         }
21028         ndr->depth--;
21029 }
21030
21031 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
21032 {
21033         if (flags & NDR_IN) {
21034         }
21035         if (flags & NDR_OUT) {
21036                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21037         }
21038         return NDR_ERR_SUCCESS;
21039 }
21040
21041 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
21042 {
21043         if (flags & NDR_IN) {
21044         }
21045         if (flags & NDR_OUT) {
21046                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21047         }
21048         return NDR_ERR_SUCCESS;
21049 }
21050
21051 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
21052 {
21053         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
21054         ndr->depth++;
21055         if (flags & NDR_SET_VALUES) {
21056                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21057         }
21058         if (flags & NDR_IN) {
21059                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
21060                 ndr->depth++;
21061                 ndr->depth--;
21062         }
21063         if (flags & NDR_OUT) {
21064                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
21065                 ndr->depth++;
21066                 ndr_print_WERROR(ndr, "result", r->out.result);
21067                 ndr->depth--;
21068         }
21069         ndr->depth--;
21070 }
21071
21072 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
21073 {
21074         if (flags & NDR_IN) {
21075         }
21076         if (flags & NDR_OUT) {
21077                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21078         }
21079         return NDR_ERR_SUCCESS;
21080 }
21081
21082 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
21083 {
21084         if (flags & NDR_IN) {
21085         }
21086         if (flags & NDR_OUT) {
21087                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21088         }
21089         return NDR_ERR_SUCCESS;
21090 }
21091
21092 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
21093 {
21094         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
21095         ndr->depth++;
21096         if (flags & NDR_SET_VALUES) {
21097                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21098         }
21099         if (flags & NDR_IN) {
21100                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
21101                 ndr->depth++;
21102                 ndr->depth--;
21103         }
21104         if (flags & NDR_OUT) {
21105                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
21106                 ndr->depth++;
21107                 ndr_print_WERROR(ndr, "result", r->out.result);
21108                 ndr->depth--;
21109         }
21110         ndr->depth--;
21111 }
21112
21113 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
21114 {
21115         if (flags & NDR_IN) {
21116         }
21117         if (flags & NDR_OUT) {
21118                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21119         }
21120         return NDR_ERR_SUCCESS;
21121 }
21122
21123 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
21124 {
21125         if (flags & NDR_IN) {
21126         }
21127         if (flags & NDR_OUT) {
21128                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21129         }
21130         return NDR_ERR_SUCCESS;
21131 }
21132
21133 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
21134 {
21135         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
21136         ndr->depth++;
21137         if (flags & NDR_SET_VALUES) {
21138                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21139         }
21140         if (flags & NDR_IN) {
21141                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
21142                 ndr->depth++;
21143                 ndr->depth--;
21144         }
21145         if (flags & NDR_OUT) {
21146                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
21147                 ndr->depth++;
21148                 ndr_print_WERROR(ndr, "result", r->out.result);
21149                 ndr->depth--;
21150         }
21151         ndr->depth--;
21152 }
21153
21154 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
21155 {
21156         if (flags & NDR_IN) {
21157         }
21158         if (flags & NDR_OUT) {
21159                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21160         }
21161         return NDR_ERR_SUCCESS;
21162 }
21163
21164 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
21165 {
21166         if (flags & NDR_IN) {
21167         }
21168         if (flags & NDR_OUT) {
21169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21170         }
21171         return NDR_ERR_SUCCESS;
21172 }
21173
21174 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
21175 {
21176         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
21177         ndr->depth++;
21178         if (flags & NDR_SET_VALUES) {
21179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21180         }
21181         if (flags & NDR_IN) {
21182                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
21183                 ndr->depth++;
21184                 ndr->depth--;
21185         }
21186         if (flags & NDR_OUT) {
21187                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
21188                 ndr->depth++;
21189                 ndr_print_WERROR(ndr, "result", r->out.result);
21190                 ndr->depth--;
21191         }
21192         ndr->depth--;
21193 }
21194
21195 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
21196 {
21197         if (flags & NDR_IN) {
21198                 if (r->in.handle == NULL) {
21199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21200                 }
21201                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21202                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
21203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
21204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
21205                 if (r->in.local_machine) {
21206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
21207                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
21209                         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));
21210                 }
21211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
21212                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
21213                 if (r->in.notify_options) {
21214                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
21215                 }
21216         }
21217         if (flags & NDR_OUT) {
21218                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21219         }
21220         return NDR_ERR_SUCCESS;
21221 }
21222
21223 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
21224 {
21225         uint32_t _ptr_local_machine;
21226         uint32_t _ptr_notify_options;
21227         TALLOC_CTX *_mem_save_handle_0;
21228         TALLOC_CTX *_mem_save_local_machine_0;
21229         TALLOC_CTX *_mem_save_notify_options_0;
21230         if (flags & NDR_IN) {
21231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21232                         NDR_PULL_ALLOC(ndr, r->in.handle);
21233                 }
21234                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21235                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21236                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21238                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
21239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
21240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
21241                 if (_ptr_local_machine) {
21242                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
21243                 } else {
21244                         r->in.local_machine = NULL;
21245                 }
21246                 if (r->in.local_machine) {
21247                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
21248                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
21249                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
21250                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
21251                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
21252                                 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));
21253                         }
21254                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
21255                         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));
21256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
21257                 }
21258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
21259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
21260                 if (_ptr_notify_options) {
21261                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
21262                 } else {
21263                         r->in.notify_options = NULL;
21264                 }
21265                 if (r->in.notify_options) {
21266                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
21267                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
21268                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
21269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
21270                 }
21271         }
21272         if (flags & NDR_OUT) {
21273                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21274         }
21275         return NDR_ERR_SUCCESS;
21276 }
21277
21278 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
21279 {
21280         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
21281         ndr->depth++;
21282         if (flags & NDR_SET_VALUES) {
21283                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21284         }
21285         if (flags & NDR_IN) {
21286                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
21287                 ndr->depth++;
21288                 ndr_print_ptr(ndr, "handle", r->in.handle);
21289                 ndr->depth++;
21290                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21291                 ndr->depth--;
21292                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
21293                 ndr_print_uint32(ndr, "options", r->in.options);
21294                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
21295                 ndr->depth++;
21296                 if (r->in.local_machine) {
21297                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
21298                 }
21299                 ndr->depth--;
21300                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
21301                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
21302                 ndr->depth++;
21303                 if (r->in.notify_options) {
21304                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
21305                 }
21306                 ndr->depth--;
21307                 ndr->depth--;
21308         }
21309         if (flags & NDR_OUT) {
21310                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
21311                 ndr->depth++;
21312                 ndr_print_WERROR(ndr, "result", r->out.result);
21313                 ndr->depth--;
21314         }
21315         ndr->depth--;
21316 }
21317
21318 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
21319 {
21320         if (flags & NDR_IN) {
21321                 if (r->in.handle == NULL) {
21322                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21323                 }
21324                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
21326                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
21327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
21328                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
21329                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21330         }
21331         if (flags & NDR_OUT) {
21332                 if (r->out.reply_result == NULL) {
21333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21334                 }
21335                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
21336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21337         }
21338         return NDR_ERR_SUCCESS;
21339 }
21340
21341 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
21342 {
21343         TALLOC_CTX *_mem_save_handle_0;
21344         TALLOC_CTX *_mem_save_reply_result_0;
21345         if (flags & NDR_IN) {
21346                 ZERO_STRUCT(r->out);
21347
21348                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21349                         NDR_PULL_ALLOC(ndr, r->in.handle);
21350                 }
21351                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21352                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21353                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21354                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
21356                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
21357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
21358                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
21359                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21360                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
21361                 ZERO_STRUCTP(r->out.reply_result);
21362         }
21363         if (flags & NDR_OUT) {
21364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21365                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
21366                 }
21367                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
21368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
21369                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
21370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
21371                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21372         }
21373         return NDR_ERR_SUCCESS;
21374 }
21375
21376 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
21377 {
21378         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
21379         ndr->depth++;
21380         if (flags & NDR_SET_VALUES) {
21381                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21382         }
21383         if (flags & NDR_IN) {
21384                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
21385                 ndr->depth++;
21386                 ndr_print_ptr(ndr, "handle", r->in.handle);
21387                 ndr->depth++;
21388                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21389                 ndr->depth--;
21390                 ndr_print_uint32(ndr, "color", r->in.color);
21391                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
21392                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
21393                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
21394                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
21395                 ndr->depth--;
21396         }
21397         if (flags & NDR_OUT) {
21398                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
21399                 ndr->depth++;
21400                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
21401                 ndr->depth++;
21402                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
21403                 ndr->depth--;
21404                 ndr_print_WERROR(ndr, "result", r->out.result);
21405                 ndr->depth--;
21406         }
21407         ndr->depth--;
21408 }
21409
21410 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
21411 {
21412         if (flags & NDR_IN) {
21413                 if (r->in.handle == NULL) {
21414                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21415                 }
21416                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
21418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
21419                 if (r->in.options) {
21420                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
21421                 }
21422         }
21423         if (flags & NDR_OUT) {
21424                 if (r->out.info == NULL) {
21425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21426                 }
21427                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
21428                 if (*r->out.info) {
21429                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
21430                 }
21431                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21432         }
21433         return NDR_ERR_SUCCESS;
21434 }
21435
21436 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
21437 {
21438         uint32_t _ptr_options;
21439         uint32_t _ptr_info;
21440         TALLOC_CTX *_mem_save_handle_0;
21441         TALLOC_CTX *_mem_save_options_0;
21442         TALLOC_CTX *_mem_save_info_0;
21443         TALLOC_CTX *_mem_save_info_1;
21444         if (flags & NDR_IN) {
21445                 ZERO_STRUCT(r->out);
21446
21447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21448                         NDR_PULL_ALLOC(ndr, r->in.handle);
21449                 }
21450                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21451                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21452                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
21455                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
21456                 if (_ptr_options) {
21457                         NDR_PULL_ALLOC(ndr, r->in.options);
21458                 } else {
21459                         r->in.options = NULL;
21460                 }
21461                 if (r->in.options) {
21462                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
21463                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
21464                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
21465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
21466                 }
21467                 NDR_PULL_ALLOC(ndr, r->out.info);
21468                 ZERO_STRUCTP(r->out.info);
21469         }
21470         if (flags & NDR_OUT) {
21471                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21472                         NDR_PULL_ALLOC(ndr, r->out.info);
21473                 }
21474                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21475                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
21476                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21477                 if (_ptr_info) {
21478                         NDR_PULL_ALLOC(ndr, *r->out.info);
21479                 } else {
21480                         *r->out.info = NULL;
21481                 }
21482                 if (*r->out.info) {
21483                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
21484                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
21485                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
21486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
21487                 }
21488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
21489                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21490         }
21491         return NDR_ERR_SUCCESS;
21492 }
21493
21494 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
21495 {
21496         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
21497         ndr->depth++;
21498         if (flags & NDR_SET_VALUES) {
21499                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21500         }
21501         if (flags & NDR_IN) {
21502                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
21503                 ndr->depth++;
21504                 ndr_print_ptr(ndr, "handle", r->in.handle);
21505                 ndr->depth++;
21506                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21507                 ndr->depth--;
21508                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
21509                 ndr_print_ptr(ndr, "options", r->in.options);
21510                 ndr->depth++;
21511                 if (r->in.options) {
21512                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
21513                 }
21514                 ndr->depth--;
21515                 ndr->depth--;
21516         }
21517         if (flags & NDR_OUT) {
21518                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
21519                 ndr->depth++;
21520                 ndr_print_ptr(ndr, "info", r->out.info);
21521                 ndr->depth++;
21522                 ndr_print_ptr(ndr, "info", *r->out.info);
21523                 ndr->depth++;
21524                 if (*r->out.info) {
21525                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
21526                 }
21527                 ndr->depth--;
21528                 ndr->depth--;
21529                 ndr_print_WERROR(ndr, "result", r->out.result);
21530                 ndr->depth--;
21531         }
21532         ndr->depth--;
21533 }
21534
21535 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
21536 {
21537         if (flags & NDR_IN) {
21538         }
21539         if (flags & NDR_OUT) {
21540                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21541         }
21542         return NDR_ERR_SUCCESS;
21543 }
21544
21545 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
21546 {
21547         if (flags & NDR_IN) {
21548         }
21549         if (flags & NDR_OUT) {
21550                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21551         }
21552         return NDR_ERR_SUCCESS;
21553 }
21554
21555 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
21556 {
21557         ndr_print_struct(ndr, name, "spoolss_44");
21558         ndr->depth++;
21559         if (flags & NDR_SET_VALUES) {
21560                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21561         }
21562         if (flags & NDR_IN) {
21563                 ndr_print_struct(ndr, "in", "spoolss_44");
21564                 ndr->depth++;
21565                 ndr->depth--;
21566         }
21567         if (flags & NDR_OUT) {
21568                 ndr_print_struct(ndr, "out", "spoolss_44");
21569                 ndr->depth++;
21570                 ndr_print_WERROR(ndr, "result", r->out.result);
21571                 ndr->depth--;
21572         }
21573         ndr->depth--;
21574 }
21575
21576 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
21577 {
21578         if (flags & NDR_IN) {
21579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
21580                 if (r->in.printername) {
21581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21582                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21583                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21584                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21585                 }
21586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
21587                 if (r->in.datatype) {
21588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21592                 }
21593                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21594                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
21595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21596                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21597                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21598         }
21599         if (flags & NDR_OUT) {
21600                 if (r->out.handle == NULL) {
21601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21602                 }
21603                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21604                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21605         }
21606         return NDR_ERR_SUCCESS;
21607 }
21608
21609 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
21610 {
21611         uint32_t _ptr_printername;
21612         uint32_t _ptr_datatype;
21613         TALLOC_CTX *_mem_save_printername_0;
21614         TALLOC_CTX *_mem_save_datatype_0;
21615         TALLOC_CTX *_mem_save_handle_0;
21616         if (flags & NDR_IN) {
21617                 ZERO_STRUCT(r->out);
21618
21619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
21620                 if (_ptr_printername) {
21621                         NDR_PULL_ALLOC(ndr, r->in.printername);
21622                 } else {
21623                         r->in.printername = NULL;
21624                 }
21625                 if (r->in.printername) {
21626                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21627                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
21628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
21629                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
21630                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
21631                                 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));
21632                         }
21633                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
21634                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
21635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
21636                 }
21637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
21638                 if (_ptr_datatype) {
21639                         NDR_PULL_ALLOC(ndr, r->in.datatype);
21640                 } else {
21641                         r->in.datatype = NULL;
21642                 }
21643                 if (r->in.datatype) {
21644                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
21645                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
21646                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
21647                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
21648                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
21649                                 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));
21650                         }
21651                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
21652                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
21653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
21654                 }
21655                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21656                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
21657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21658                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21659                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21660                 NDR_PULL_ALLOC(ndr, r->out.handle);
21661                 ZERO_STRUCTP(r->out.handle);
21662         }
21663         if (flags & NDR_OUT) {
21664                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21665                         NDR_PULL_ALLOC(ndr, r->out.handle);
21666                 }
21667                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21668                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21669                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21670                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21672         }
21673         return NDR_ERR_SUCCESS;
21674 }
21675
21676 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
21677 {
21678         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
21679         ndr->depth++;
21680         if (flags & NDR_SET_VALUES) {
21681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21682         }
21683         if (flags & NDR_IN) {
21684                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
21685                 ndr->depth++;
21686                 ndr_print_ptr(ndr, "printername", r->in.printername);
21687                 ndr->depth++;
21688                 if (r->in.printername) {
21689                         ndr_print_string(ndr, "printername", r->in.printername);
21690                 }
21691                 ndr->depth--;
21692                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
21693                 ndr->depth++;
21694                 if (r->in.datatype) {
21695                         ndr_print_string(ndr, "datatype", r->in.datatype);
21696                 }
21697                 ndr->depth--;
21698                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
21699                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
21700                 ndr_print_uint32(ndr, "level", r->in.level);
21701                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
21702                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
21703                 ndr->depth--;
21704         }
21705         if (flags & NDR_OUT) {
21706                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
21707                 ndr->depth++;
21708                 ndr_print_ptr(ndr, "handle", r->out.handle);
21709                 ndr->depth++;
21710                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21711                 ndr->depth--;
21712                 ndr_print_WERROR(ndr, "result", r->out.result);
21713                 ndr->depth--;
21714         }
21715         ndr->depth--;
21716 }
21717
21718 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
21719 {
21720         if (flags & NDR_IN) {
21721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21722                 if (r->in.server) {
21723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21727                 }
21728                 if (r->in.info_ctr == NULL) {
21729                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21730                 }
21731                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21732                 if (r->in.devmode_ctr == NULL) {
21733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21734                 }
21735                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21736                 if (r->in.secdesc_ctr == NULL) {
21737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21738                 }
21739                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21740                 if (r->in.userlevel_ctr == NULL) {
21741                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21742                 }
21743                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21744         }
21745         if (flags & NDR_OUT) {
21746                 if (r->out.handle == NULL) {
21747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21748                 }
21749                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21750                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21751         }
21752         return NDR_ERR_SUCCESS;
21753 }
21754
21755 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
21756 {
21757         uint32_t _ptr_server;
21758         TALLOC_CTX *_mem_save_server_0;
21759         TALLOC_CTX *_mem_save_info_ctr_0;
21760         TALLOC_CTX *_mem_save_devmode_ctr_0;
21761         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21762         TALLOC_CTX *_mem_save_userlevel_ctr_0;
21763         TALLOC_CTX *_mem_save_handle_0;
21764         if (flags & NDR_IN) {
21765                 ZERO_STRUCT(r->out);
21766
21767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21768                 if (_ptr_server) {
21769                         NDR_PULL_ALLOC(ndr, r->in.server);
21770                 } else {
21771                         r->in.server = NULL;
21772                 }
21773                 if (r->in.server) {
21774                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21775                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21776                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21777                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21778                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21779                                 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));
21780                         }
21781                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21782                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21784                 }
21785                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21786                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21787                 }
21788                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21789                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21790                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21791                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21792                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21793                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21794                 }
21795                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21796                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21797                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21798                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21800                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21801                 }
21802                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21804                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21807                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
21808                 }
21809                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21810                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
21811                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21813                 NDR_PULL_ALLOC(ndr, r->out.handle);
21814                 ZERO_STRUCTP(r->out.handle);
21815         }
21816         if (flags & NDR_OUT) {
21817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21818                         NDR_PULL_ALLOC(ndr, r->out.handle);
21819                 }
21820                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21821                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21822                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21825         }
21826         return NDR_ERR_SUCCESS;
21827 }
21828
21829 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
21830 {
21831         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
21832         ndr->depth++;
21833         if (flags & NDR_SET_VALUES) {
21834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21835         }
21836         if (flags & NDR_IN) {
21837                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
21838                 ndr->depth++;
21839                 ndr_print_ptr(ndr, "server", r->in.server);
21840                 ndr->depth++;
21841                 if (r->in.server) {
21842                         ndr_print_string(ndr, "server", r->in.server);
21843                 }
21844                 ndr->depth--;
21845                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21846                 ndr->depth++;
21847                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21848                 ndr->depth--;
21849                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21850                 ndr->depth++;
21851                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21852                 ndr->depth--;
21853                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21854                 ndr->depth++;
21855                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21856                 ndr->depth--;
21857                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21858                 ndr->depth++;
21859                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21860                 ndr->depth--;
21861                 ndr->depth--;
21862         }
21863         if (flags & NDR_OUT) {
21864                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
21865                 ndr->depth++;
21866                 ndr_print_ptr(ndr, "handle", r->out.handle);
21867                 ndr->depth++;
21868                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21869                 ndr->depth--;
21870                 ndr_print_WERROR(ndr, "result", r->out.result);
21871                 ndr->depth--;
21872         }
21873         ndr->depth--;
21874 }
21875
21876 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
21877 {
21878         if (flags & NDR_IN) {
21879         }
21880         if (flags & NDR_OUT) {
21881                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21882         }
21883         return NDR_ERR_SUCCESS;
21884 }
21885
21886 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
21887 {
21888         if (flags & NDR_IN) {
21889         }
21890         if (flags & NDR_OUT) {
21891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21892         }
21893         return NDR_ERR_SUCCESS;
21894 }
21895
21896 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
21897 {
21898         ndr_print_struct(ndr, name, "spoolss_47");
21899         ndr->depth++;
21900         if (flags & NDR_SET_VALUES) {
21901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21902         }
21903         if (flags & NDR_IN) {
21904                 ndr_print_struct(ndr, "in", "spoolss_47");
21905                 ndr->depth++;
21906                 ndr->depth--;
21907         }
21908         if (flags & NDR_OUT) {
21909                 ndr_print_struct(ndr, "out", "spoolss_47");
21910                 ndr->depth++;
21911                 ndr_print_WERROR(ndr, "result", r->out.result);
21912                 ndr->depth--;
21913         }
21914         ndr->depth--;
21915 }
21916
21917 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
21918 {
21919         if (flags & NDR_IN) {
21920                 if (r->in.handle == NULL) {
21921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21922                 }
21923                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
21925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
21926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
21927         }
21928         if (flags & NDR_OUT) {
21929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
21930                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
21931                 if (r->out.value_needed == NULL) {
21932                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21933                 }
21934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
21935                 if (r->out.printerdata_type == NULL) {
21936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21937                 }
21938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
21939                 if (r->out.buffer == NULL) {
21940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21941                 }
21942                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
21943                 if (r->out.data_needed == NULL) {
21944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21945                 }
21946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
21947                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21948         }
21949         return NDR_ERR_SUCCESS;
21950 }
21951
21952 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
21953 {
21954         TALLOC_CTX *_mem_save_handle_0;
21955         TALLOC_CTX *_mem_save_value_needed_0;
21956         TALLOC_CTX *_mem_save_printerdata_type_0;
21957         TALLOC_CTX *_mem_save_buffer_0;
21958         TALLOC_CTX *_mem_save_data_needed_0;
21959         if (flags & NDR_IN) {
21960                 ZERO_STRUCT(r->out);
21961
21962                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21963                         NDR_PULL_ALLOC(ndr, r->in.handle);
21964                 }
21965                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21966                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21967                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21968                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
21970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
21971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
21972                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
21973                 ZERO_STRUCTP(r->out.value_needed);
21974                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21975                 ZERO_STRUCTP(r->out.printerdata_type);
21976                 NDR_PULL_ALLOC(ndr, r->out.buffer);
21977                 ZERO_STRUCTP(r->out.buffer);
21978                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
21979                 ZERO_STRUCTP(r->out.data_needed);
21980         }
21981         if (flags & NDR_OUT) {
21982                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
21983                 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));
21984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21985                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
21986                 }
21987                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21988                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
21989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
21990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
21991                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21992                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21993                 }
21994                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21995                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
21996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
21997                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
21998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21999                         NDR_PULL_ALLOC(ndr, r->out.buffer);
22000                 }
22001                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22002                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
22003                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
22004                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
22005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22006                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
22007                 }
22008                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22009                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
22010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
22011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
22012                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22013                 if (r->out.value_name) {
22014                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
22015                 }
22016         }
22017         return NDR_ERR_SUCCESS;
22018 }
22019
22020 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
22021 {
22022         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
22023         ndr->depth++;
22024         if (flags & NDR_SET_VALUES) {
22025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22026         }
22027         if (flags & NDR_IN) {
22028                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
22029                 ndr->depth++;
22030                 ndr_print_ptr(ndr, "handle", r->in.handle);
22031                 ndr->depth++;
22032                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22033                 ndr->depth--;
22034                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
22035                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
22036                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
22037                 ndr->depth--;
22038         }
22039         if (flags & NDR_OUT) {
22040                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
22041                 ndr->depth++;
22042                 ndr_print_string(ndr, "value_name", r->out.value_name);
22043                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
22044                 ndr->depth++;
22045                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
22046                 ndr->depth--;
22047                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
22048                 ndr->depth++;
22049                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
22050                 ndr->depth--;
22051                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22052                 ndr->depth++;
22053                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
22054                 ndr->depth--;
22055                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
22056                 ndr->depth++;
22057                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
22058                 ndr->depth--;
22059                 ndr_print_WERROR(ndr, "result", r->out.result);
22060                 ndr->depth--;
22061         }
22062         ndr->depth--;
22063 }
22064
22065 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
22066 {
22067         if (flags & NDR_IN) {
22068                 if (r->in.handle == NULL) {
22069                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22070                 }
22071                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22075                 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));
22076         }
22077         if (flags & NDR_OUT) {
22078                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22079         }
22080         return NDR_ERR_SUCCESS;
22081 }
22082
22083 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
22084 {
22085         TALLOC_CTX *_mem_save_handle_0;
22086         if (flags & NDR_IN) {
22087                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22088                         NDR_PULL_ALLOC(ndr, r->in.handle);
22089                 }
22090                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22092                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22094                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22095                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22096                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22097                         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));
22098                 }
22099                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22100                 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));
22101         }
22102         if (flags & NDR_OUT) {
22103                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22104         }
22105         return NDR_ERR_SUCCESS;
22106 }
22107
22108 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
22109 {
22110         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
22111         ndr->depth++;
22112         if (flags & NDR_SET_VALUES) {
22113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22114         }
22115         if (flags & NDR_IN) {
22116                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
22117                 ndr->depth++;
22118                 ndr_print_ptr(ndr, "handle", r->in.handle);
22119                 ndr->depth++;
22120                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22121                 ndr->depth--;
22122                 ndr_print_string(ndr, "value_name", r->in.value_name);
22123                 ndr->depth--;
22124         }
22125         if (flags & NDR_OUT) {
22126                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
22127                 ndr->depth++;
22128                 ndr_print_WERROR(ndr, "result", r->out.result);
22129                 ndr->depth--;
22130         }
22131         ndr->depth--;
22132 }
22133
22134 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
22135 {
22136         if (flags & NDR_IN) {
22137         }
22138         if (flags & NDR_OUT) {
22139                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22140         }
22141         return NDR_ERR_SUCCESS;
22142 }
22143
22144 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
22145 {
22146         if (flags & NDR_IN) {
22147         }
22148         if (flags & NDR_OUT) {
22149                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22150         }
22151         return NDR_ERR_SUCCESS;
22152 }
22153
22154 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
22155 {
22156         ndr_print_struct(ndr, name, "spoolss_4a");
22157         ndr->depth++;
22158         if (flags & NDR_SET_VALUES) {
22159                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22160         }
22161         if (flags & NDR_IN) {
22162                 ndr_print_struct(ndr, "in", "spoolss_4a");
22163                 ndr->depth++;
22164                 ndr->depth--;
22165         }
22166         if (flags & NDR_OUT) {
22167                 ndr_print_struct(ndr, "out", "spoolss_4a");
22168                 ndr->depth++;
22169                 ndr_print_WERROR(ndr, "result", r->out.result);
22170                 ndr->depth--;
22171         }
22172         ndr->depth--;
22173 }
22174
22175 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
22176 {
22177         if (flags & NDR_IN) {
22178         }
22179         if (flags & NDR_OUT) {
22180                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22181         }
22182         return NDR_ERR_SUCCESS;
22183 }
22184
22185 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
22186 {
22187         if (flags & NDR_IN) {
22188         }
22189         if (flags & NDR_OUT) {
22190                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22191         }
22192         return NDR_ERR_SUCCESS;
22193 }
22194
22195 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
22196 {
22197         ndr_print_struct(ndr, name, "spoolss_4b");
22198         ndr->depth++;
22199         if (flags & NDR_SET_VALUES) {
22200                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22201         }
22202         if (flags & NDR_IN) {
22203                 ndr_print_struct(ndr, "in", "spoolss_4b");
22204                 ndr->depth++;
22205                 ndr->depth--;
22206         }
22207         if (flags & NDR_OUT) {
22208                 ndr_print_struct(ndr, "out", "spoolss_4b");
22209                 ndr->depth++;
22210                 ndr_print_WERROR(ndr, "result", r->out.result);
22211                 ndr->depth--;
22212         }
22213         ndr->depth--;
22214 }
22215
22216 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
22217 {
22218         if (flags & NDR_IN) {
22219         }
22220         if (flags & NDR_OUT) {
22221                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22222         }
22223         return NDR_ERR_SUCCESS;
22224 }
22225
22226 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
22227 {
22228         if (flags & NDR_IN) {
22229         }
22230         if (flags & NDR_OUT) {
22231                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22232         }
22233         return NDR_ERR_SUCCESS;
22234 }
22235
22236 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
22237 {
22238         ndr_print_struct(ndr, name, "spoolss_4c");
22239         ndr->depth++;
22240         if (flags & NDR_SET_VALUES) {
22241                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22242         }
22243         if (flags & NDR_IN) {
22244                 ndr_print_struct(ndr, "in", "spoolss_4c");
22245                 ndr->depth++;
22246                 ndr->depth--;
22247         }
22248         if (flags & NDR_OUT) {
22249                 ndr_print_struct(ndr, "out", "spoolss_4c");
22250                 ndr->depth++;
22251                 ndr_print_WERROR(ndr, "result", r->out.result);
22252                 ndr->depth--;
22253         }
22254         ndr->depth--;
22255 }
22256
22257 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
22258 {
22259         if (flags & NDR_IN) {
22260                 if (r->in.handle == NULL) {
22261                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22262                 }
22263                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22267                 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));
22268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22271                 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));
22272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
22273                 if (r->in.buffer == NULL) {
22274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22275                 }
22276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22277                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
22278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22279         }
22280         if (flags & NDR_OUT) {
22281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22282         }
22283         return NDR_ERR_SUCCESS;
22284 }
22285
22286 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
22287 {
22288         TALLOC_CTX *_mem_save_handle_0;
22289         if (flags & NDR_IN) {
22290                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22291                         NDR_PULL_ALLOC(ndr, r->in.handle);
22292                 }
22293                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22294                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22295                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22297                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22298                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22299                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22300                         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));
22301                 }
22302                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22303                 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));
22304                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22305                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22306                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22307                         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));
22308                 }
22309                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22310                 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));
22311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
22312                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22313                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22314                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22315                 }
22316                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22318                 if (r->in.buffer) {
22319                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
22320                 }
22321         }
22322         if (flags & NDR_OUT) {
22323                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22324         }
22325         return NDR_ERR_SUCCESS;
22326 }
22327
22328 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
22329 {
22330         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
22331         ndr->depth++;
22332         if (flags & NDR_SET_VALUES) {
22333                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22334         }
22335         if (flags & NDR_IN) {
22336                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
22337                 ndr->depth++;
22338                 ndr_print_ptr(ndr, "handle", r->in.handle);
22339                 ndr->depth++;
22340                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22341                 ndr->depth--;
22342                 ndr_print_string(ndr, "key_name", r->in.key_name);
22343                 ndr_print_string(ndr, "value_name", r->in.value_name);
22344                 ndr_print_uint32(ndr, "type", r->in.type);
22345                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22346                 ndr->depth++;
22347                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
22348                 ndr->depth--;
22349                 ndr_print_uint32(ndr, "offered", r->in.offered);
22350                 ndr->depth--;
22351         }
22352         if (flags & NDR_OUT) {
22353                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
22354                 ndr->depth++;
22355                 ndr_print_WERROR(ndr, "result", r->out.result);
22356                 ndr->depth--;
22357         }
22358         ndr->depth--;
22359 }
22360
22361 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
22362 {
22363         if (flags & NDR_IN) {
22364                 if (r->in.handle == NULL) {
22365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22366                 }
22367                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22371                 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));
22372                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22375                 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));
22376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22377         }
22378         if (flags & NDR_OUT) {
22379                 if (r->out.type == NULL) {
22380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22381                 }
22382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
22383                 if (r->out.buffer == NULL) {
22384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22385                 }
22386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22387                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22388                 if (r->out.needed == NULL) {
22389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22390                 }
22391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22392                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22393         }
22394         return NDR_ERR_SUCCESS;
22395 }
22396
22397 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
22398 {
22399         TALLOC_CTX *_mem_save_handle_0;
22400         TALLOC_CTX *_mem_save_type_0;
22401         TALLOC_CTX *_mem_save_needed_0;
22402         if (flags & NDR_IN) {
22403                 ZERO_STRUCT(r->out);
22404
22405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22406                         NDR_PULL_ALLOC(ndr, r->in.handle);
22407                 }
22408                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22410                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22412                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22413                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22414                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22415                         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));
22416                 }
22417                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22418                 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));
22419                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22420                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22421                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22422                         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));
22423                 }
22424                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22425                 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));
22426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22427                 NDR_PULL_ALLOC(ndr, r->out.type);
22428                 ZERO_STRUCTP(r->out.type);
22429                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
22430                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
22431                 NDR_PULL_ALLOC(ndr, r->out.needed);
22432                 ZERO_STRUCTP(r->out.needed);
22433         }
22434         if (flags & NDR_OUT) {
22435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22436                         NDR_PULL_ALLOC(ndr, r->out.type);
22437                 }
22438                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
22439                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
22440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
22441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
22442                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22444                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22445                 }
22446                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22448                         NDR_PULL_ALLOC(ndr, r->out.needed);
22449                 }
22450                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22451                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22454                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22455                 if (r->out.buffer) {
22456                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22457                 }
22458         }
22459         return NDR_ERR_SUCCESS;
22460 }
22461
22462 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
22463 {
22464         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
22465         ndr->depth++;
22466         if (flags & NDR_SET_VALUES) {
22467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22468         }
22469         if (flags & NDR_IN) {
22470                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
22471                 ndr->depth++;
22472                 ndr_print_ptr(ndr, "handle", r->in.handle);
22473                 ndr->depth++;
22474                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22475                 ndr->depth--;
22476                 ndr_print_string(ndr, "key_name", r->in.key_name);
22477                 ndr_print_string(ndr, "value_name", r->in.value_name);
22478                 ndr_print_uint32(ndr, "offered", r->in.offered);
22479                 ndr->depth--;
22480         }
22481         if (flags & NDR_OUT) {
22482                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
22483                 ndr->depth++;
22484                 ndr_print_ptr(ndr, "type", r->out.type);
22485                 ndr->depth++;
22486                 ndr_print_uint32(ndr, "type", *r->out.type);
22487                 ndr->depth--;
22488                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22489                 ndr->depth++;
22490                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22491                 ndr->depth--;
22492                 ndr_print_ptr(ndr, "needed", r->out.needed);
22493                 ndr->depth++;
22494                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22495                 ndr->depth--;
22496                 ndr_print_WERROR(ndr, "result", r->out.result);
22497                 ndr->depth--;
22498         }
22499         ndr->depth--;
22500 }
22501
22502 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
22503 {
22504         if (flags & NDR_IN) {
22505                 if (r->in.handle == NULL) {
22506                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22507                 }
22508                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22512                 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));
22513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22514         }
22515         if (flags & NDR_OUT) {
22516                 if (r->out.buffer == NULL) {
22517                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22518                 }
22519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22520                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22521                 if (r->out.needed == NULL) {
22522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22523                 }
22524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22525                 if (r->out.count == NULL) {
22526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22527                 }
22528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22529                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22530         }
22531         return NDR_ERR_SUCCESS;
22532 }
22533
22534 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
22535 {
22536         TALLOC_CTX *_mem_save_handle_0;
22537         TALLOC_CTX *_mem_save_needed_0;
22538         TALLOC_CTX *_mem_save_count_0;
22539         if (flags & NDR_IN) {
22540                 ZERO_STRUCT(r->out);
22541
22542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22543                         NDR_PULL_ALLOC(ndr, r->in.handle);
22544                 }
22545                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22546                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22547                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22549                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22550                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22551                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22552                         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));
22553                 }
22554                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22555                 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));
22556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22557                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
22558                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
22559                 NDR_PULL_ALLOC(ndr, r->out.needed);
22560                 ZERO_STRUCTP(r->out.needed);
22561                 NDR_PULL_ALLOC(ndr, r->out.count);
22562                 ZERO_STRUCTP(r->out.count);
22563         }
22564         if (flags & NDR_OUT) {
22565                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22566                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22567                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22568                 }
22569                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22571                         NDR_PULL_ALLOC(ndr, r->out.needed);
22572                 }
22573                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22574                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22578                         NDR_PULL_ALLOC(ndr, r->out.count);
22579                 }
22580                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22581                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22585                 if (r->out.buffer) {
22586                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22587                 }
22588         }
22589         return NDR_ERR_SUCCESS;
22590 }
22591
22592 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
22593 {
22594         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
22595         ndr->depth++;
22596         if (flags & NDR_SET_VALUES) {
22597                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22598         }
22599         if (flags & NDR_IN) {
22600                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
22601                 ndr->depth++;
22602                 ndr_print_ptr(ndr, "handle", r->in.handle);
22603                 ndr->depth++;
22604                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22605                 ndr->depth--;
22606                 ndr_print_string(ndr, "key_name", r->in.key_name);
22607                 ndr_print_uint32(ndr, "offered", r->in.offered);
22608                 ndr->depth--;
22609         }
22610         if (flags & NDR_OUT) {
22611                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
22612                 ndr->depth++;
22613                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22614                 ndr->depth++;
22615                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22616                 ndr->depth--;
22617                 ndr_print_ptr(ndr, "needed", r->out.needed);
22618                 ndr->depth++;
22619                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22620                 ndr->depth--;
22621                 ndr_print_ptr(ndr, "count", r->out.count);
22622                 ndr->depth++;
22623                 ndr_print_uint32(ndr, "count", *r->out.count);
22624                 ndr->depth--;
22625                 ndr_print_WERROR(ndr, "result", r->out.result);
22626                 ndr->depth--;
22627         }
22628         ndr->depth--;
22629 }
22630
22631 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
22632 {
22633         uint32_t cntr_key_buffer_1;
22634         if (flags & NDR_IN) {
22635                 if (r->in.handle == NULL) {
22636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22637                 }
22638                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22642                 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));
22643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
22644         }
22645         if (flags & NDR_OUT) {
22646                 if (r->out.key_buffer == NULL) {
22647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22648                 }
22649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
22650                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22651                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
22652                 }
22653                 if (r->out.needed == NULL) {
22654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22655                 }
22656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22657                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22658         }
22659         return NDR_ERR_SUCCESS;
22660 }
22661
22662 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
22663 {
22664         uint32_t cntr_key_buffer_1;
22665         TALLOC_CTX *_mem_save_handle_0;
22666         TALLOC_CTX *_mem_save_key_buffer_1;
22667         TALLOC_CTX *_mem_save_needed_0;
22668         if (flags & NDR_IN) {
22669                 ZERO_STRUCT(r->out);
22670
22671                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22672                         NDR_PULL_ALLOC(ndr, r->in.handle);
22673                 }
22674                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22675                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22676                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22677                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22678                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22679                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22680                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22681                         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));
22682                 }
22683                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22684                 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));
22685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
22686                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
22687                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
22688                 NDR_PULL_ALLOC(ndr, r->out.needed);
22689                 ZERO_STRUCTP(r->out.needed);
22690         }
22691         if (flags & NDR_OUT) {
22692                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
22693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22694                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
22695                 }
22696                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
22697                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
22698                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22699                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
22700                 }
22701                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
22702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22703                         NDR_PULL_ALLOC(ndr, r->out.needed);
22704                 }
22705                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22706                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22709                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22710                 if (r->out.key_buffer) {
22711                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
22712                 }
22713         }
22714         return NDR_ERR_SUCCESS;
22715 }
22716
22717 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
22718 {
22719         uint32_t cntr_key_buffer_1;
22720         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
22721         ndr->depth++;
22722         if (flags & NDR_SET_VALUES) {
22723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22724         }
22725         if (flags & NDR_IN) {
22726                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
22727                 ndr->depth++;
22728                 ndr_print_ptr(ndr, "handle", r->in.handle);
22729                 ndr->depth++;
22730                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22731                 ndr->depth--;
22732                 ndr_print_string(ndr, "key_name", r->in.key_name);
22733                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
22734                 ndr->depth--;
22735         }
22736         if (flags & NDR_OUT) {
22737                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
22738                 ndr->depth++;
22739                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
22740                 ndr->depth++;
22741                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
22742                 ndr->depth++;
22743                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
22744                         char *idx_1=NULL;
22745                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
22746                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
22747                                 free(idx_1);
22748                         }
22749                 }
22750                 ndr->depth--;
22751                 ndr->depth--;
22752                 ndr_print_ptr(ndr, "needed", r->out.needed);
22753                 ndr->depth++;
22754                 ndr_print_uint32(ndr, "needed", *r->out.needed);
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_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
22763 {
22764         if (flags & NDR_IN) {
22765                 if (r->in.handle == NULL) {
22766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22767                 }
22768                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22772                 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));
22773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22776                 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));
22777         }
22778         if (flags & NDR_OUT) {
22779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22780         }
22781         return NDR_ERR_SUCCESS;
22782 }
22783
22784 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
22785 {
22786         TALLOC_CTX *_mem_save_handle_0;
22787         if (flags & NDR_IN) {
22788                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22789                         NDR_PULL_ALLOC(ndr, r->in.handle);
22790                 }
22791                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22792                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22793                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22794                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22795                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22796                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22797                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22798                         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));
22799                 }
22800                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22801                 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));
22802                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22803                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22804                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22805                         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));
22806                 }
22807                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22808                 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));
22809         }
22810         if (flags & NDR_OUT) {
22811                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22812         }
22813         return NDR_ERR_SUCCESS;
22814 }
22815
22816 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
22817 {
22818         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
22819         ndr->depth++;
22820         if (flags & NDR_SET_VALUES) {
22821                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22822         }
22823         if (flags & NDR_IN) {
22824                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
22825                 ndr->depth++;
22826                 ndr_print_ptr(ndr, "handle", r->in.handle);
22827                 ndr->depth++;
22828                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22829                 ndr->depth--;
22830                 ndr_print_string(ndr, "key_name", r->in.key_name);
22831                 ndr_print_string(ndr, "value_name", r->in.value_name);
22832                 ndr->depth--;
22833         }
22834         if (flags & NDR_OUT) {
22835                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
22836                 ndr->depth++;
22837                 ndr_print_WERROR(ndr, "result", r->out.result);
22838                 ndr->depth--;
22839         }
22840         ndr->depth--;
22841 }
22842
22843 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
22844 {
22845         if (flags & NDR_IN) {
22846                 if (r->in.handle == NULL) {
22847                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22848                 }
22849                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22853                 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));
22854         }
22855         if (flags & NDR_OUT) {
22856                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22857         }
22858         return NDR_ERR_SUCCESS;
22859 }
22860
22861 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
22862 {
22863         TALLOC_CTX *_mem_save_handle_0;
22864         if (flags & NDR_IN) {
22865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22866                         NDR_PULL_ALLOC(ndr, r->in.handle);
22867                 }
22868                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22869                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22870                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22872                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22873                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22874                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22875                         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));
22876                 }
22877                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22878                 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));
22879         }
22880         if (flags & NDR_OUT) {
22881                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22882         }
22883         return NDR_ERR_SUCCESS;
22884 }
22885
22886 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
22887 {
22888         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
22889         ndr->depth++;
22890         if (flags & NDR_SET_VALUES) {
22891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22892         }
22893         if (flags & NDR_IN) {
22894                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
22895                 ndr->depth++;
22896                 ndr_print_ptr(ndr, "handle", r->in.handle);
22897                 ndr->depth++;
22898                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22899                 ndr->depth--;
22900                 ndr_print_string(ndr, "key_name", r->in.key_name);
22901                 ndr->depth--;
22902         }
22903         if (flags & NDR_OUT) {
22904                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
22905                 ndr->depth++;
22906                 ndr_print_WERROR(ndr, "result", r->out.result);
22907                 ndr->depth--;
22908         }
22909         ndr->depth--;
22910 }
22911
22912 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
22913 {
22914         if (flags & NDR_IN) {
22915         }
22916         if (flags & NDR_OUT) {
22917                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22918         }
22919         return NDR_ERR_SUCCESS;
22920 }
22921
22922 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
22923 {
22924         if (flags & NDR_IN) {
22925         }
22926         if (flags & NDR_OUT) {
22927                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22928         }
22929         return NDR_ERR_SUCCESS;
22930 }
22931
22932 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
22933 {
22934         ndr_print_struct(ndr, name, "spoolss_53");
22935         ndr->depth++;
22936         if (flags & NDR_SET_VALUES) {
22937                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22938         }
22939         if (flags & NDR_IN) {
22940                 ndr_print_struct(ndr, "in", "spoolss_53");
22941                 ndr->depth++;
22942                 ndr->depth--;
22943         }
22944         if (flags & NDR_OUT) {
22945                 ndr_print_struct(ndr, "out", "spoolss_53");
22946                 ndr->depth++;
22947                 ndr_print_WERROR(ndr, "result", r->out.result);
22948                 ndr->depth--;
22949         }
22950         ndr->depth--;
22951 }
22952
22953 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22954 {
22955         if (flags & NDR_IN) {
22956                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22957                 if (r->in.server) {
22958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22962                 }
22963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22966                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22970                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22971                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
22972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
22973         }
22974         if (flags & NDR_OUT) {
22975                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22976         }
22977         return NDR_ERR_SUCCESS;
22978 }
22979
22980 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
22981 {
22982         uint32_t _ptr_server;
22983         TALLOC_CTX *_mem_save_server_0;
22984         if (flags & NDR_IN) {
22985                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22986                 if (_ptr_server) {
22987                         NDR_PULL_ALLOC(ndr, r->in.server);
22988                 } else {
22989                         r->in.server = NULL;
22990                 }
22991                 if (r->in.server) {
22992                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22993                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22996                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22997                                 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));
22998                         }
22999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
23000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
23001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
23002                 }
23003                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
23004                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
23005                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
23006                         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));
23007                 }
23008                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
23009                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
23010                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
23011                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
23012                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
23013                         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));
23014                 }
23015                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
23016                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
23017                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
23018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
23019         }
23020         if (flags & NDR_OUT) {
23021                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23022         }
23023         return NDR_ERR_SUCCESS;
23024 }
23025
23026 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
23027 {
23028         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
23029         ndr->depth++;
23030         if (flags & NDR_SET_VALUES) {
23031                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23032         }
23033         if (flags & NDR_IN) {
23034                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
23035                 ndr->depth++;
23036                 ndr_print_ptr(ndr, "server", r->in.server);
23037                 ndr->depth++;
23038                 if (r->in.server) {
23039                         ndr_print_string(ndr, "server", r->in.server);
23040                 }
23041                 ndr->depth--;
23042                 ndr_print_string(ndr, "architecture", r->in.architecture);
23043                 ndr_print_string(ndr, "driver", r->in.driver);
23044                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
23045                 ndr_print_uint32(ndr, "version", r->in.version);
23046                 ndr->depth--;
23047         }
23048         if (flags & NDR_OUT) {
23049                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
23050                 ndr->depth++;
23051                 ndr_print_WERROR(ndr, "result", r->out.result);
23052                 ndr->depth--;
23053         }
23054         ndr->depth--;
23055 }
23056
23057 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
23058 {
23059         if (flags & NDR_IN) {
23060         }
23061         if (flags & NDR_OUT) {
23062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23063         }
23064         return NDR_ERR_SUCCESS;
23065 }
23066
23067 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
23068 {
23069         if (flags & NDR_IN) {
23070         }
23071         if (flags & NDR_OUT) {
23072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23073         }
23074         return NDR_ERR_SUCCESS;
23075 }
23076
23077 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
23078 {
23079         ndr_print_struct(ndr, name, "spoolss_55");
23080         ndr->depth++;
23081         if (flags & NDR_SET_VALUES) {
23082                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23083         }
23084         if (flags & NDR_IN) {
23085                 ndr_print_struct(ndr, "in", "spoolss_55");
23086                 ndr->depth++;
23087                 ndr->depth--;
23088         }
23089         if (flags & NDR_OUT) {
23090                 ndr_print_struct(ndr, "out", "spoolss_55");
23091                 ndr->depth++;
23092                 ndr_print_WERROR(ndr, "result", r->out.result);
23093                 ndr->depth--;
23094         }
23095         ndr->depth--;
23096 }
23097
23098 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
23099 {
23100         if (flags & NDR_IN) {
23101         }
23102         if (flags & NDR_OUT) {
23103                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23104         }
23105         return NDR_ERR_SUCCESS;
23106 }
23107
23108 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
23109 {
23110         if (flags & NDR_IN) {
23111         }
23112         if (flags & NDR_OUT) {
23113                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23114         }
23115         return NDR_ERR_SUCCESS;
23116 }
23117
23118 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
23119 {
23120         ndr_print_struct(ndr, name, "spoolss_56");
23121         ndr->depth++;
23122         if (flags & NDR_SET_VALUES) {
23123                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23124         }
23125         if (flags & NDR_IN) {
23126                 ndr_print_struct(ndr, "in", "spoolss_56");
23127                 ndr->depth++;
23128                 ndr->depth--;
23129         }
23130         if (flags & NDR_OUT) {
23131                 ndr_print_struct(ndr, "out", "spoolss_56");
23132                 ndr->depth++;
23133                 ndr_print_WERROR(ndr, "result", r->out.result);
23134                 ndr->depth--;
23135         }
23136         ndr->depth--;
23137 }
23138
23139 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
23140 {
23141         if (flags & NDR_IN) {
23142         }
23143         if (flags & NDR_OUT) {
23144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23145         }
23146         return NDR_ERR_SUCCESS;
23147 }
23148
23149 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
23150 {
23151         if (flags & NDR_IN) {
23152         }
23153         if (flags & NDR_OUT) {
23154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23155         }
23156         return NDR_ERR_SUCCESS;
23157 }
23158
23159 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
23160 {
23161         ndr_print_struct(ndr, name, "spoolss_57");
23162         ndr->depth++;
23163         if (flags & NDR_SET_VALUES) {
23164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23165         }
23166         if (flags & NDR_IN) {
23167                 ndr_print_struct(ndr, "in", "spoolss_57");
23168                 ndr->depth++;
23169                 ndr->depth--;
23170         }
23171         if (flags & NDR_OUT) {
23172                 ndr_print_struct(ndr, "out", "spoolss_57");
23173                 ndr->depth++;
23174                 ndr_print_WERROR(ndr, "result", r->out.result);
23175                 ndr->depth--;
23176         }
23177         ndr->depth--;
23178 }
23179
23180 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
23181 {
23182         if (flags & NDR_IN) {
23183                 if (r->in.handle == NULL) {
23184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23185                 }
23186                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
23188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
23190                 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));
23191                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
23192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
23193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
23194                 if (r->in.status_code == NULL) {
23195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23196                 }
23197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
23198         }
23199         if (flags & NDR_OUT) {
23200                 if (r->out.out_data == NULL) {
23201                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23202                 }
23203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
23204                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
23205                 if (r->out.needed == NULL) {
23206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23207                 }
23208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23209                 if (r->out.status_code == NULL) {
23210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23211                 }
23212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
23213                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23214         }
23215         return NDR_ERR_SUCCESS;
23216 }
23217
23218 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
23219 {
23220         TALLOC_CTX *_mem_save_handle_0;
23221         TALLOC_CTX *_mem_save_needed_0;
23222         TALLOC_CTX *_mem_save_status_code_0;
23223         if (flags & NDR_IN) {
23224                 ZERO_STRUCT(r->out);
23225
23226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23227                         NDR_PULL_ALLOC(ndr, r->in.handle);
23228                 }
23229                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23230                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23231                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23232                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23233                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
23234                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
23235                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
23236                         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));
23237                 }
23238                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
23239                 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));
23240                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
23241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
23242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
23243                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23244                         NDR_PULL_ALLOC(ndr, r->in.status_code);
23245                 }
23246                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
23247                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
23248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
23249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
23250                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
23251                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
23252                 NDR_PULL_ALLOC(ndr, r->out.needed);
23253                 ZERO_STRUCTP(r->out.needed);
23254                 NDR_PULL_ALLOC(ndr, r->out.status_code);
23255                 *r->out.status_code = *r->in.status_code;
23256         }
23257         if (flags & NDR_OUT) {
23258                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
23259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23260                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
23261                 }
23262                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
23263                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23264                         NDR_PULL_ALLOC(ndr, r->out.needed);
23265                 }
23266                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23267                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23269                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23270                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23271                         NDR_PULL_ALLOC(ndr, r->out.status_code);
23272                 }
23273                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
23274                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
23275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
23276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
23277                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23278                 if (r->out.out_data) {
23279                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
23280                 }
23281         }
23282         return NDR_ERR_SUCCESS;
23283 }
23284
23285 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
23286 {
23287         ndr_print_struct(ndr, name, "spoolss_XcvData");
23288         ndr->depth++;
23289         if (flags & NDR_SET_VALUES) {
23290                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23291         }
23292         if (flags & NDR_IN) {
23293                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
23294                 ndr->depth++;
23295                 ndr_print_ptr(ndr, "handle", r->in.handle);
23296                 ndr->depth++;
23297                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23298                 ndr->depth--;
23299                 ndr_print_string(ndr, "function_name", r->in.function_name);
23300                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
23301                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
23302                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
23303                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
23304                 ndr->depth++;
23305                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
23306                 ndr->depth--;
23307                 ndr->depth--;
23308         }
23309         if (flags & NDR_OUT) {
23310                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
23311                 ndr->depth++;
23312                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
23313                 ndr->depth++;
23314                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
23315                 ndr->depth--;
23316                 ndr_print_ptr(ndr, "needed", r->out.needed);
23317                 ndr->depth++;
23318                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23319                 ndr->depth--;
23320                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
23321                 ndr->depth++;
23322                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
23323                 ndr->depth--;
23324                 ndr_print_WERROR(ndr, "result", r->out.result);
23325                 ndr->depth--;
23326         }
23327         ndr->depth--;
23328 }
23329
23330 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
23331 {
23332         if (flags & NDR_IN) {
23333                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23334                 if (r->in.servername) {
23335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23338                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23339                 }
23340                 if (r->in.info_ctr == NULL) {
23341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23342                 }
23343                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
23344                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
23345         }
23346         if (flags & NDR_OUT) {
23347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23348         }
23349         return NDR_ERR_SUCCESS;
23350 }
23351
23352 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
23353 {
23354         uint32_t _ptr_servername;
23355         TALLOC_CTX *_mem_save_servername_0;
23356         TALLOC_CTX *_mem_save_info_ctr_0;
23357         if (flags & NDR_IN) {
23358                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23359                 if (_ptr_servername) {
23360                         NDR_PULL_ALLOC(ndr, r->in.servername);
23361                 } else {
23362                         r->in.servername = NULL;
23363                 }
23364                 if (r->in.servername) {
23365                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23366                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23367                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23368                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23369                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23370                                 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));
23371                         }
23372                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23373                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23375                 }
23376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23377                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
23378                 }
23379                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23380                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
23381                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
23382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23383                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
23384         }
23385         if (flags & NDR_OUT) {
23386                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23387         }
23388         return NDR_ERR_SUCCESS;
23389 }
23390
23391 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
23392 {
23393         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
23394         ndr->depth++;
23395         if (flags & NDR_SET_VALUES) {
23396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23397         }
23398         if (flags & NDR_IN) {
23399                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
23400                 ndr->depth++;
23401                 ndr_print_ptr(ndr, "servername", r->in.servername);
23402                 ndr->depth++;
23403                 if (r->in.servername) {
23404                         ndr_print_string(ndr, "servername", r->in.servername);
23405                 }
23406                 ndr->depth--;
23407                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
23408                 ndr->depth++;
23409                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
23410                 ndr->depth--;
23411                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
23412                 ndr->depth--;
23413         }
23414         if (flags & NDR_OUT) {
23415                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
23416                 ndr->depth++;
23417                 ndr_print_WERROR(ndr, "result", r->out.result);
23418                 ndr->depth--;
23419         }
23420         ndr->depth--;
23421 }
23422
23423 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
23424 {
23425         if (flags & NDR_IN) {
23426         }
23427         if (flags & NDR_OUT) {
23428                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23429         }
23430         return NDR_ERR_SUCCESS;
23431 }
23432
23433 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
23434 {
23435         if (flags & NDR_IN) {
23436         }
23437         if (flags & NDR_OUT) {
23438                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23439         }
23440         return NDR_ERR_SUCCESS;
23441 }
23442
23443 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
23444 {
23445         ndr_print_struct(ndr, name, "spoolss_5a");
23446         ndr->depth++;
23447         if (flags & NDR_SET_VALUES) {
23448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23449         }
23450         if (flags & NDR_IN) {
23451                 ndr_print_struct(ndr, "in", "spoolss_5a");
23452                 ndr->depth++;
23453                 ndr->depth--;
23454         }
23455         if (flags & NDR_OUT) {
23456                 ndr_print_struct(ndr, "out", "spoolss_5a");
23457                 ndr->depth++;
23458                 ndr_print_WERROR(ndr, "result", r->out.result);
23459                 ndr->depth--;
23460         }
23461         ndr->depth--;
23462 }
23463
23464 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
23465 {
23466         if (flags & NDR_IN) {
23467         }
23468         if (flags & NDR_OUT) {
23469                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23470         }
23471         return NDR_ERR_SUCCESS;
23472 }
23473
23474 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
23475 {
23476         if (flags & NDR_IN) {
23477         }
23478         if (flags & NDR_OUT) {
23479                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23480         }
23481         return NDR_ERR_SUCCESS;
23482 }
23483
23484 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
23485 {
23486         ndr_print_struct(ndr, name, "spoolss_5b");
23487         ndr->depth++;
23488         if (flags & NDR_SET_VALUES) {
23489                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23490         }
23491         if (flags & NDR_IN) {
23492                 ndr_print_struct(ndr, "in", "spoolss_5b");
23493                 ndr->depth++;
23494                 ndr->depth--;
23495         }
23496         if (flags & NDR_OUT) {
23497                 ndr_print_struct(ndr, "out", "spoolss_5b");
23498                 ndr->depth++;
23499                 ndr_print_WERROR(ndr, "result", r->out.result);
23500                 ndr->depth--;
23501         }
23502         ndr->depth--;
23503 }
23504
23505 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
23506 {
23507         if (flags & NDR_IN) {
23508         }
23509         if (flags & NDR_OUT) {
23510                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23511         }
23512         return NDR_ERR_SUCCESS;
23513 }
23514
23515 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
23516 {
23517         if (flags & NDR_IN) {
23518         }
23519         if (flags & NDR_OUT) {
23520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23521         }
23522         return NDR_ERR_SUCCESS;
23523 }
23524
23525 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
23526 {
23527         ndr_print_struct(ndr, name, "spoolss_5c");
23528         ndr->depth++;
23529         if (flags & NDR_SET_VALUES) {
23530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23531         }
23532         if (flags & NDR_IN) {
23533                 ndr_print_struct(ndr, "in", "spoolss_5c");
23534                 ndr->depth++;
23535                 ndr->depth--;
23536         }
23537         if (flags & NDR_OUT) {
23538                 ndr_print_struct(ndr, "out", "spoolss_5c");
23539                 ndr->depth++;
23540                 ndr_print_WERROR(ndr, "result", r->out.result);
23541                 ndr->depth--;
23542         }
23543         ndr->depth--;
23544 }
23545
23546 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
23547 {
23548         if (flags & NDR_IN) {
23549         }
23550         if (flags & NDR_OUT) {
23551                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23552         }
23553         return NDR_ERR_SUCCESS;
23554 }
23555
23556 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
23557 {
23558         if (flags & NDR_IN) {
23559         }
23560         if (flags & NDR_OUT) {
23561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23562         }
23563         return NDR_ERR_SUCCESS;
23564 }
23565
23566 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
23567 {
23568         ndr_print_struct(ndr, name, "spoolss_5d");
23569         ndr->depth++;
23570         if (flags & NDR_SET_VALUES) {
23571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23572         }
23573         if (flags & NDR_IN) {
23574                 ndr_print_struct(ndr, "in", "spoolss_5d");
23575                 ndr->depth++;
23576                 ndr->depth--;
23577         }
23578         if (flags & NDR_OUT) {
23579                 ndr_print_struct(ndr, "out", "spoolss_5d");
23580                 ndr->depth++;
23581                 ndr_print_WERROR(ndr, "result", r->out.result);
23582                 ndr->depth--;
23583         }
23584         ndr->depth--;
23585 }
23586
23587 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
23588 {
23589         if (flags & NDR_IN) {
23590         }
23591         if (flags & NDR_OUT) {
23592                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23593         }
23594         return NDR_ERR_SUCCESS;
23595 }
23596
23597 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
23598 {
23599         if (flags & NDR_IN) {
23600         }
23601         if (flags & NDR_OUT) {
23602                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23603         }
23604         return NDR_ERR_SUCCESS;
23605 }
23606
23607 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
23608 {
23609         ndr_print_struct(ndr, name, "spoolss_5e");
23610         ndr->depth++;
23611         if (flags & NDR_SET_VALUES) {
23612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23613         }
23614         if (flags & NDR_IN) {
23615                 ndr_print_struct(ndr, "in", "spoolss_5e");
23616                 ndr->depth++;
23617                 ndr->depth--;
23618         }
23619         if (flags & NDR_OUT) {
23620                 ndr_print_struct(ndr, "out", "spoolss_5e");
23621                 ndr->depth++;
23622                 ndr_print_WERROR(ndr, "result", r->out.result);
23623                 ndr->depth--;
23624         }
23625         ndr->depth--;
23626 }
23627
23628 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
23629 {
23630         if (flags & NDR_IN) {
23631         }
23632         if (flags & NDR_OUT) {
23633                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23634         }
23635         return NDR_ERR_SUCCESS;
23636 }
23637
23638 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
23639 {
23640         if (flags & NDR_IN) {
23641         }
23642         if (flags & NDR_OUT) {
23643                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23644         }
23645         return NDR_ERR_SUCCESS;
23646 }
23647
23648 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
23649 {
23650         ndr_print_struct(ndr, name, "spoolss_5f");
23651         ndr->depth++;
23652         if (flags & NDR_SET_VALUES) {
23653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23654         }
23655         if (flags & NDR_IN) {
23656                 ndr_print_struct(ndr, "in", "spoolss_5f");
23657                 ndr->depth++;
23658                 ndr->depth--;
23659         }
23660         if (flags & NDR_OUT) {
23661                 ndr_print_struct(ndr, "out", "spoolss_5f");
23662                 ndr->depth++;
23663                 ndr_print_WERROR(ndr, "result", r->out.result);
23664                 ndr->depth--;
23665         }
23666         ndr->depth--;
23667 }
23668
23669 static const struct ndr_interface_call spoolss_calls[] = {
23670         {
23671                 "spoolss_EnumPrinters",
23672                 sizeof(struct spoolss_EnumPrinters),
23673                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
23674                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
23675                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
23676                 false,
23677         },
23678         {
23679                 "spoolss_OpenPrinter",
23680                 sizeof(struct spoolss_OpenPrinter),
23681                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
23682                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
23683                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
23684                 false,
23685         },
23686         {
23687                 "spoolss_SetJob",
23688                 sizeof(struct spoolss_SetJob),
23689                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
23690                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
23691                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
23692                 false,
23693         },
23694         {
23695                 "spoolss_GetJob",
23696                 sizeof(struct spoolss_GetJob),
23697                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
23698                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
23699                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
23700                 false,
23701         },
23702         {
23703                 "spoolss_EnumJobs",
23704                 sizeof(struct spoolss_EnumJobs),
23705                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
23706                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
23707                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
23708                 false,
23709         },
23710         {
23711                 "spoolss_AddPrinter",
23712                 sizeof(struct spoolss_AddPrinter),
23713                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
23714                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
23715                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
23716                 false,
23717         },
23718         {
23719                 "spoolss_DeletePrinter",
23720                 sizeof(struct spoolss_DeletePrinter),
23721                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
23722                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
23723                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
23724                 false,
23725         },
23726         {
23727                 "spoolss_SetPrinter",
23728                 sizeof(struct spoolss_SetPrinter),
23729                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
23730                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
23731                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
23732                 false,
23733         },
23734         {
23735                 "spoolss_GetPrinter",
23736                 sizeof(struct spoolss_GetPrinter),
23737                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
23738                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
23739                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
23740                 false,
23741         },
23742         {
23743                 "spoolss_AddPrinterDriver",
23744                 sizeof(struct spoolss_AddPrinterDriver),
23745                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
23746                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
23747                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
23748                 false,
23749         },
23750         {
23751                 "spoolss_EnumPrinterDrivers",
23752                 sizeof(struct spoolss_EnumPrinterDrivers),
23753                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
23754                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
23755                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
23756                 false,
23757         },
23758         {
23759                 "spoolss_GetPrinterDriver",
23760                 sizeof(struct spoolss_GetPrinterDriver),
23761                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
23762                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
23763                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
23764                 false,
23765         },
23766         {
23767                 "spoolss_GetPrinterDriverDirectory",
23768                 sizeof(struct spoolss_GetPrinterDriverDirectory),
23769                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
23770                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
23771                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
23772                 false,
23773         },
23774         {
23775                 "spoolss_DeletePrinterDriver",
23776                 sizeof(struct spoolss_DeletePrinterDriver),
23777                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
23778                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
23779                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
23780                 false,
23781         },
23782         {
23783                 "spoolss_AddPrintProcessor",
23784                 sizeof(struct spoolss_AddPrintProcessor),
23785                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
23786                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
23787                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
23788                 false,
23789         },
23790         {
23791                 "spoolss_EnumPrintProcessors",
23792                 sizeof(struct spoolss_EnumPrintProcessors),
23793                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
23794                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
23795                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
23796                 false,
23797         },
23798         {
23799                 "spoolss_GetPrintProcessorDirectory",
23800                 sizeof(struct spoolss_GetPrintProcessorDirectory),
23801                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
23802                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
23803                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
23804                 false,
23805         },
23806         {
23807                 "spoolss_StartDocPrinter",
23808                 sizeof(struct spoolss_StartDocPrinter),
23809                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
23810                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
23811                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
23812                 false,
23813         },
23814         {
23815                 "spoolss_StartPagePrinter",
23816                 sizeof(struct spoolss_StartPagePrinter),
23817                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
23818                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
23819                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
23820                 false,
23821         },
23822         {
23823                 "spoolss_WritePrinter",
23824                 sizeof(struct spoolss_WritePrinter),
23825                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
23826                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
23827                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
23828                 false,
23829         },
23830         {
23831                 "spoolss_EndPagePrinter",
23832                 sizeof(struct spoolss_EndPagePrinter),
23833                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
23834                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
23835                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
23836                 false,
23837         },
23838         {
23839                 "spoolss_AbortPrinter",
23840                 sizeof(struct spoolss_AbortPrinter),
23841                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
23842                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
23843                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
23844                 false,
23845         },
23846         {
23847                 "spoolss_ReadPrinter",
23848                 sizeof(struct spoolss_ReadPrinter),
23849                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
23850                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
23851                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
23852                 false,
23853         },
23854         {
23855                 "spoolss_EndDocPrinter",
23856                 sizeof(struct spoolss_EndDocPrinter),
23857                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
23858                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
23859                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
23860                 false,
23861         },
23862         {
23863                 "spoolss_AddJob",
23864                 sizeof(struct spoolss_AddJob),
23865                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
23866                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
23867                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
23868                 false,
23869         },
23870         {
23871                 "spoolss_ScheduleJob",
23872                 sizeof(struct spoolss_ScheduleJob),
23873                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
23874                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
23875                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
23876                 false,
23877         },
23878         {
23879                 "spoolss_GetPrinterData",
23880                 sizeof(struct spoolss_GetPrinterData),
23881                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
23882                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
23883                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
23884                 false,
23885         },
23886         {
23887                 "spoolss_SetPrinterData",
23888                 sizeof(struct spoolss_SetPrinterData),
23889                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
23890                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
23891                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
23892                 false,
23893         },
23894         {
23895                 "spoolss_WaitForPrinterChange",
23896                 sizeof(struct spoolss_WaitForPrinterChange),
23897                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
23898                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
23899                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
23900                 false,
23901         },
23902         {
23903                 "spoolss_ClosePrinter",
23904                 sizeof(struct spoolss_ClosePrinter),
23905                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
23906                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
23907                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
23908                 false,
23909         },
23910         {
23911                 "spoolss_AddForm",
23912                 sizeof(struct spoolss_AddForm),
23913                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
23914                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
23915                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
23916                 false,
23917         },
23918         {
23919                 "spoolss_DeleteForm",
23920                 sizeof(struct spoolss_DeleteForm),
23921                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
23922                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
23923                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
23924                 false,
23925         },
23926         {
23927                 "spoolss_GetForm",
23928                 sizeof(struct spoolss_GetForm),
23929                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
23930                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
23931                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
23932                 false,
23933         },
23934         {
23935                 "spoolss_SetForm",
23936                 sizeof(struct spoolss_SetForm),
23937                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
23938                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
23939                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
23940                 false,
23941         },
23942         {
23943                 "spoolss_EnumForms",
23944                 sizeof(struct spoolss_EnumForms),
23945                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
23946                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
23947                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
23948                 false,
23949         },
23950         {
23951                 "spoolss_EnumPorts",
23952                 sizeof(struct spoolss_EnumPorts),
23953                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
23954                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
23955                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
23956                 false,
23957         },
23958         {
23959                 "spoolss_EnumMonitors",
23960                 sizeof(struct spoolss_EnumMonitors),
23961                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
23962                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
23963                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
23964                 false,
23965         },
23966         {
23967                 "spoolss_AddPort",
23968                 sizeof(struct spoolss_AddPort),
23969                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
23970                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
23971                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
23972                 false,
23973         },
23974         {
23975                 "spoolss_ConfigurePort",
23976                 sizeof(struct spoolss_ConfigurePort),
23977                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
23978                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
23979                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
23980                 false,
23981         },
23982         {
23983                 "spoolss_DeletePort",
23984                 sizeof(struct spoolss_DeletePort),
23985                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
23986                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
23987                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
23988                 false,
23989         },
23990         {
23991                 "spoolss_CreatePrinterIC",
23992                 sizeof(struct spoolss_CreatePrinterIC),
23993                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
23994                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
23995                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
23996                 false,
23997         },
23998         {
23999                 "spoolss_PlayGDIScriptOnPrinterIC",
24000                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
24001                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
24002                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
24003                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
24004                 false,
24005         },
24006         {
24007                 "spoolss_DeletePrinterIC",
24008                 sizeof(struct spoolss_DeletePrinterIC),
24009                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
24010                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
24011                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
24012                 false,
24013         },
24014         {
24015                 "spoolss_AddPrinterConnection",
24016                 sizeof(struct spoolss_AddPrinterConnection),
24017                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
24018                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
24019                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
24020                 false,
24021         },
24022         {
24023                 "spoolss_DeletePrinterConnection",
24024                 sizeof(struct spoolss_DeletePrinterConnection),
24025                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
24026                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
24027                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
24028                 false,
24029         },
24030         {
24031                 "spoolss_PrinterMessageBox",
24032                 sizeof(struct spoolss_PrinterMessageBox),
24033                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
24034                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
24035                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
24036                 false,
24037         },
24038         {
24039                 "spoolss_AddMonitor",
24040                 sizeof(struct spoolss_AddMonitor),
24041                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
24042                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
24043                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
24044                 false,
24045         },
24046         {
24047                 "spoolss_DeleteMonitor",
24048                 sizeof(struct spoolss_DeleteMonitor),
24049                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
24050                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
24051                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
24052                 false,
24053         },
24054         {
24055                 "spoolss_DeletePrintProcessor",
24056                 sizeof(struct spoolss_DeletePrintProcessor),
24057                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
24058                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
24059                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
24060                 false,
24061         },
24062         {
24063                 "spoolss_AddPrintProvidor",
24064                 sizeof(struct spoolss_AddPrintProvidor),
24065                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
24066                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
24067                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
24068                 false,
24069         },
24070         {
24071                 "spoolss_DeletePrintProvidor",
24072                 sizeof(struct spoolss_DeletePrintProvidor),
24073                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
24074                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
24075                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
24076                 false,
24077         },
24078         {
24079                 "spoolss_EnumPrintProcDataTypes",
24080                 sizeof(struct spoolss_EnumPrintProcDataTypes),
24081                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
24082                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
24083                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
24084                 false,
24085         },
24086         {
24087                 "spoolss_ResetPrinter",
24088                 sizeof(struct spoolss_ResetPrinter),
24089                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
24090                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
24091                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
24092                 false,
24093         },
24094         {
24095                 "spoolss_GetPrinterDriver2",
24096                 sizeof(struct spoolss_GetPrinterDriver2),
24097                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
24098                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
24099                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
24100                 false,
24101         },
24102         {
24103                 "spoolss_FindFirstPrinterChangeNotification",
24104                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
24105                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
24106                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
24107                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
24108                 false,
24109         },
24110         {
24111                 "spoolss_FindNextPrinterChangeNotification",
24112                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
24113                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
24114                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
24115                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
24116                 false,
24117         },
24118         {
24119                 "spoolss_FindClosePrinterNotify",
24120                 sizeof(struct spoolss_FindClosePrinterNotify),
24121                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
24122                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
24123                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
24124                 false,
24125         },
24126         {
24127                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
24128                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
24129                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
24130                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
24131                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
24132                 false,
24133         },
24134         {
24135                 "spoolss_ReplyOpenPrinter",
24136                 sizeof(struct spoolss_ReplyOpenPrinter),
24137                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
24138                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
24139                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
24140                 false,
24141         },
24142         {
24143                 "spoolss_RouterReplyPrinter",
24144                 sizeof(struct spoolss_RouterReplyPrinter),
24145                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
24146                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
24147                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
24148                 false,
24149         },
24150         {
24151                 "spoolss_ReplyClosePrinter",
24152                 sizeof(struct spoolss_ReplyClosePrinter),
24153                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
24154                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
24155                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
24156                 false,
24157         },
24158         {
24159                 "spoolss_AddPortEx",
24160                 sizeof(struct spoolss_AddPortEx),
24161                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
24162                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
24163                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
24164                 false,
24165         },
24166         {
24167                 "spoolss_RouterFindFirstPrinterChangeNotification",
24168                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
24169                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
24170                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
24171                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
24172                 false,
24173         },
24174         {
24175                 "spoolss_SpoolerInit",
24176                 sizeof(struct spoolss_SpoolerInit),
24177                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
24178                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
24179                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
24180                 false,
24181         },
24182         {
24183                 "spoolss_ResetPrinterEx",
24184                 sizeof(struct spoolss_ResetPrinterEx),
24185                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
24186                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
24187                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
24188                 false,
24189         },
24190         {
24191                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
24192                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
24193                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
24194                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
24195                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
24196                 false,
24197         },
24198         {
24199                 "spoolss_RouterReplyPrinterEx",
24200                 sizeof(struct spoolss_RouterReplyPrinterEx),
24201                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
24202                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
24203                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
24204                 false,
24205         },
24206         {
24207                 "spoolss_RouterRefreshPrinterChangeNotify",
24208                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
24209                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
24210                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
24211                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
24212                 false,
24213         },
24214         {
24215                 "spoolss_44",
24216                 sizeof(struct spoolss_44),
24217                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
24218                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
24219                 (ndr_print_function_t) ndr_print_spoolss_44,
24220                 false,
24221         },
24222         {
24223                 "spoolss_OpenPrinterEx",
24224                 sizeof(struct spoolss_OpenPrinterEx),
24225                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
24226                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
24227                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
24228                 false,
24229         },
24230         {
24231                 "spoolss_AddPrinterEx",
24232                 sizeof(struct spoolss_AddPrinterEx),
24233                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
24234                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
24235                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
24236                 false,
24237         },
24238         {
24239                 "spoolss_47",
24240                 sizeof(struct spoolss_47),
24241                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
24242                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
24243                 (ndr_print_function_t) ndr_print_spoolss_47,
24244                 false,
24245         },
24246         {
24247                 "spoolss_EnumPrinterData",
24248                 sizeof(struct spoolss_EnumPrinterData),
24249                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
24250                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
24251                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
24252                 false,
24253         },
24254         {
24255                 "spoolss_DeletePrinterData",
24256                 sizeof(struct spoolss_DeletePrinterData),
24257                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
24258                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
24259                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
24260                 false,
24261         },
24262         {
24263                 "spoolss_4a",
24264                 sizeof(struct spoolss_4a),
24265                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
24266                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
24267                 (ndr_print_function_t) ndr_print_spoolss_4a,
24268                 false,
24269         },
24270         {
24271                 "spoolss_4b",
24272                 sizeof(struct spoolss_4b),
24273                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
24274                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
24275                 (ndr_print_function_t) ndr_print_spoolss_4b,
24276                 false,
24277         },
24278         {
24279                 "spoolss_4c",
24280                 sizeof(struct spoolss_4c),
24281                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
24282                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
24283                 (ndr_print_function_t) ndr_print_spoolss_4c,
24284                 false,
24285         },
24286         {
24287                 "spoolss_SetPrinterDataEx",
24288                 sizeof(struct spoolss_SetPrinterDataEx),
24289                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
24290                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
24291                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
24292                 false,
24293         },
24294         {
24295                 "spoolss_GetPrinterDataEx",
24296                 sizeof(struct spoolss_GetPrinterDataEx),
24297                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
24298                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
24299                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
24300                 false,
24301         },
24302         {
24303                 "spoolss_EnumPrinterDataEx",
24304                 sizeof(struct spoolss_EnumPrinterDataEx),
24305                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
24306                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
24307                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
24308                 false,
24309         },
24310         {
24311                 "spoolss_EnumPrinterKey",
24312                 sizeof(struct spoolss_EnumPrinterKey),
24313                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
24314                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
24315                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
24316                 false,
24317         },
24318         {
24319                 "spoolss_DeletePrinterDataEx",
24320                 sizeof(struct spoolss_DeletePrinterDataEx),
24321                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
24322                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
24323                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
24324                 false,
24325         },
24326         {
24327                 "spoolss_DeletePrinterKey",
24328                 sizeof(struct spoolss_DeletePrinterKey),
24329                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
24330                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
24331                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
24332                 false,
24333         },
24334         {
24335                 "spoolss_53",
24336                 sizeof(struct spoolss_53),
24337                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
24338                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
24339                 (ndr_print_function_t) ndr_print_spoolss_53,
24340                 false,
24341         },
24342         {
24343                 "spoolss_DeletePrinterDriverEx",
24344                 sizeof(struct spoolss_DeletePrinterDriverEx),
24345                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
24346                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
24347                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
24348                 false,
24349         },
24350         {
24351                 "spoolss_55",
24352                 sizeof(struct spoolss_55),
24353                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
24354                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
24355                 (ndr_print_function_t) ndr_print_spoolss_55,
24356                 false,
24357         },
24358         {
24359                 "spoolss_56",
24360                 sizeof(struct spoolss_56),
24361                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
24362                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
24363                 (ndr_print_function_t) ndr_print_spoolss_56,
24364                 false,
24365         },
24366         {
24367                 "spoolss_57",
24368                 sizeof(struct spoolss_57),
24369                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
24370                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
24371                 (ndr_print_function_t) ndr_print_spoolss_57,
24372                 false,
24373         },
24374         {
24375                 "spoolss_XcvData",
24376                 sizeof(struct spoolss_XcvData),
24377                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
24378                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
24379                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
24380                 false,
24381         },
24382         {
24383                 "spoolss_AddPrinterDriverEx",
24384                 sizeof(struct spoolss_AddPrinterDriverEx),
24385                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
24386                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
24387                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
24388                 false,
24389         },
24390         {
24391                 "spoolss_5a",
24392                 sizeof(struct spoolss_5a),
24393                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
24394                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
24395                 (ndr_print_function_t) ndr_print_spoolss_5a,
24396                 false,
24397         },
24398         {
24399                 "spoolss_5b",
24400                 sizeof(struct spoolss_5b),
24401                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
24402                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
24403                 (ndr_print_function_t) ndr_print_spoolss_5b,
24404                 false,
24405         },
24406         {
24407                 "spoolss_5c",
24408                 sizeof(struct spoolss_5c),
24409                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
24410                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
24411                 (ndr_print_function_t) ndr_print_spoolss_5c,
24412                 false,
24413         },
24414         {
24415                 "spoolss_5d",
24416                 sizeof(struct spoolss_5d),
24417                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
24418                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
24419                 (ndr_print_function_t) ndr_print_spoolss_5d,
24420                 false,
24421         },
24422         {
24423                 "spoolss_5e",
24424                 sizeof(struct spoolss_5e),
24425                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
24426                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
24427                 (ndr_print_function_t) ndr_print_spoolss_5e,
24428                 false,
24429         },
24430         {
24431                 "spoolss_5f",
24432                 sizeof(struct spoolss_5f),
24433                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
24434                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
24435                 (ndr_print_function_t) ndr_print_spoolss_5f,
24436                 false,
24437         },
24438         { NULL, 0, NULL, NULL, NULL, false }
24439 };
24440
24441 static const char * const spoolss_endpoint_strings[] = {
24442         "ncacn_np:[\\pipe\\spoolss]",
24443 };
24444
24445 static const struct ndr_interface_string_array spoolss_endpoints = {
24446         .count  = 1,
24447         .names  = spoolss_endpoint_strings
24448 };
24449
24450 static const char * const spoolss_authservice_strings[] = {
24451         "host",
24452 };
24453
24454 static const struct ndr_interface_string_array spoolss_authservices = {
24455         .count  = 1,
24456         .names  = spoolss_authservice_strings
24457 };
24458
24459
24460 const struct ndr_interface_table ndr_table_spoolss = {
24461         .name           = "spoolss",
24462         .syntax_id      = {
24463                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
24464                 NDR_SPOOLSS_VERSION
24465         },
24466         .helpstring     = NDR_SPOOLSS_HELPSTRING,
24467         .num_calls      = 96,
24468         .calls          = spoolss_calls,
24469         .endpoints      = &spoolss_endpoints,
24470         .authservices   = &spoolss_authservices
24471 };
24472