librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 228 {
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_push_align(ndr, 4));
 231                 {
 232                         uint32_t _flags_save_string = ndr->flags;
 233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 235                         ndr->flags = _flags_save_string;
 236                 }
 237                 {
 238                         uint32_t _flags_save_string = ndr->flags;
 239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 241                         ndr->flags = _flags_save_string;
 242                 }
 243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 246                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
 257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 258                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 265                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 270         }
 271         if (ndr_flags & NDR_BUFFERS) {
 272                 {
 273                         uint32_t _flags_save_string = ndr->flags;
 274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 275                         if (r->printername) {
 276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 278                         }
 279                         ndr->flags = _flags_save_string;
 280                 }
 281                 {
 282                         uint32_t _flags_save_string = ndr->flags;
 283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 284                         if (r->servername) {
 285                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 286                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 287                         }
 288                         ndr->flags = _flags_save_string;
 289                 }
 290         }
 291         return NDR_ERR_SUCCESS;
 292 }
 293
 294 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 295 {
 296         uint32_t _ptr_printername;
 297         TALLOC_CTX *_mem_save_printername_0;
 298         uint32_t _ptr_servername;
 299         TALLOC_CTX *_mem_save_servername_0;
 300         if (ndr_flags & NDR_SCALARS) {
 301                 NDR_CHECK(ndr_pull_align(ndr, 4));
 302                 {
 303                         uint32_t _flags_save_string = ndr->flags;
 304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 306                         if (_ptr_printername) {
 307                                 NDR_PULL_ALLOC(ndr, r->printername);
 308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 309                         } else {
 310                                 r->printername = NULL;
 311                         }
 312                         ndr->flags = _flags_save_string;
 313                 }
 314                 {
 315                         uint32_t _flags_save_string = ndr->flags;
 316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 318                         if (_ptr_servername) {
 319                                 NDR_PULL_ALLOC(ndr, r->servername);
 320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 321                         } else {
 322                                 r->servername = NULL;
 323                         }
 324                         ndr->flags = _flags_save_string;
 325                 }
 326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 329                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
 340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 341                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 348                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 349                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 353         }
 354         if (ndr_flags & NDR_BUFFERS) {
 355                 {
 356                         uint32_t _flags_save_string = ndr->flags;
 357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 358                         if (r->printername) {
 359                                 uint32_t _relative_save_offset;
 360                                 _relative_save_offset = ndr->offset;
 361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 362                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 363                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 366                                 ndr->offset = _relative_save_offset;
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370                 {
 371                         uint32_t _flags_save_string = ndr->flags;
 372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 373                         if (r->servername) {
 374                                 uint32_t _relative_save_offset;
 375                                 _relative_save_offset = ndr->offset;
 376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 377                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 378                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 379                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 381                                 ndr->offset = _relative_save_offset;
 382                         }
 383                         ndr->flags = _flags_save_string;
 384                 }
 385         }
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 390 {
 391         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 392         ndr->depth++;
 393         ndr_print_ptr(ndr, "printername", r->printername);
 394         ndr->depth++;
 395         if (r->printername) {
 396                 ndr_print_string(ndr, "printername", r->printername);
 397         }
 398         ndr->depth--;
 399         ndr_print_ptr(ndr, "servername", r->servername);
 400         ndr->depth++;
 401         if (r->servername) {
 402                 ndr_print_string(ndr, "servername", r->servername);
 403         }
 404         ndr->depth--;
 405         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 406         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 407         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 408         ndr_print_spoolss_Time(ndr, "time", &r->time);
 409         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 410         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 411         ndr_print_uint32(ndr, "version", r->version);
 412         ndr_print_uint32(ndr, "free_build", r->free_build);
 413         ndr_print_uint32(ndr, "spooling", r->spooling);
 414         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 415         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 416         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 417         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 418         ndr_print_uint32(ndr, "job_error", r->job_error);
 419         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 420         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 421         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 422         ndr_print_uint32(ndr, "change_id", r->change_id);
 423         ndr_print_WERROR(ndr, "last_error", r->last_error);
 424         ndr_print_uint32(ndr, "status", r->status);
 425         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 426         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 427         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 428         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 429         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 430         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 431         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 432         ndr->depth--;
 433 }
 434
 435 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 436 {
 437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 438         return NDR_ERR_SUCCESS;
 439 }
 440
 441 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 442 {
 443         uint32_t v;
 444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 445         *r = v;
 446         return NDR_ERR_SUCCESS;
 447 }
 448
 449 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 450 {
 451         ndr_print_uint32(ndr, name, r);
 452         ndr->depth++;
 453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 464         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 465         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 466         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 467         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 468         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 469         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 470         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 474         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 478         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 480         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 481         ndr->depth--;
 482 }
 483
 484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 485 {
 486         if (ndr_flags & NDR_SCALARS) {
 487                 NDR_CHECK(ndr_push_align(ndr, 4));
 488                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 489                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 490                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 491                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 492                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 493                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 494                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 496                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 497                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 498                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 499                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 500                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 501                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 502                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 503                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 504                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 505                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 506                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 507                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 508                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 522                 {
 523                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 525                         {
 526                                 struct ndr_push *_ndr_driverextra_data;
 527                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 528                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 529                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 530                         }
 531                         ndr->flags = _flags_save_DATA_BLOB;
 532                 }
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535         }
 536         return NDR_ERR_SUCCESS;
 537 }
 538
 539 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 540 {
 541         if (ndr_flags & NDR_SCALARS) {
 542                 NDR_CHECK(ndr_pull_align(ndr, 4));
 543                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 544                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 545                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 546                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 547                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 548                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 549                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 550                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 551                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 552                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 553                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 554                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 555                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 556                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 557                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 558                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 559                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 560                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 562                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 563                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 577                 {
 578                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 580                         {
 581                                 struct ndr_pull *_ndr_driverextra_data;
 582                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 583                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 584                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 585                         }
 586                         ndr->flags = _flags_save_DATA_BLOB;
 587                 }
 588         }
 589         if (ndr_flags & NDR_BUFFERS) {
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 595 {
 596         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 597         ndr->depth++;
 598         ndr_print_string(ndr, "devicename", r->devicename);
 599         ndr_print_uint16(ndr, "specversion", r->specversion);
 600         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 601         ndr_print_uint16(ndr, "size", r->size);
 602         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 603         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 604         ndr_print_uint16(ndr, "orientation", r->orientation);
 605         ndr_print_uint16(ndr, "papersize", r->papersize);
 606         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 607         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 608         ndr_print_uint16(ndr, "scale", r->scale);
 609         ndr_print_uint16(ndr, "copies", r->copies);
 610         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 611         ndr_print_uint16(ndr, "printquality", r->printquality);
 612         ndr_print_uint16(ndr, "color", r->color);
 613         ndr_print_uint16(ndr, "duplex", r->duplex);
 614         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 615         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 616         ndr_print_uint16(ndr, "collate", r->collate);
 617         ndr_print_string(ndr, "formname", r->formname);
 618         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 619         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 620         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 621         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 622         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 623         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 624         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 625         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 626         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 627         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 628         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 629         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 630         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 631         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 632         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 633         ndr->depth--;
 634 }
 635
 636 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 637 {
 638         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 639 }
 640
 641 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 642 {
 643         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 644         return NDR_ERR_SUCCESS;
 645 }
 646
 647 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 648 {
 649         uint32_t v;
 650         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 651         *r = v;
 652         return NDR_ERR_SUCCESS;
 653 }
 654
 655 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 656 {
 657         ndr_print_uint32(ndr, name, r);
 658         ndr->depth++;
 659         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 660         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 678         ndr->depth--;
 679 }
 680
 681 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 682 {
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_push_align(ndr, 4));
 685                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 686                 {
 687                         uint32_t _flags_save_string = ndr->flags;
 688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 689                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 690                         ndr->flags = _flags_save_string;
 691                 }
 692                 {
 693                         uint32_t _flags_save_string = ndr->flags;
 694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 695                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 696                         ndr->flags = _flags_save_string;
 697                 }
 698                 {
 699                         uint32_t _flags_save_string = ndr->flags;
 700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 701                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 702                         ndr->flags = _flags_save_string;
 703                 }
 704         }
 705         if (ndr_flags & NDR_BUFFERS) {
 706                 {
 707                         uint32_t _flags_save_string = ndr->flags;
 708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 709                         if (r->name) {
 710                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 712                         }
 713                         ndr->flags = _flags_save_string;
 714                 }
 715                 {
 716                         uint32_t _flags_save_string = ndr->flags;
 717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 718                         if (r->description) {
 719                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 720                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 721                         }
 722                         ndr->flags = _flags_save_string;
 723                 }
 724                 {
 725                         uint32_t _flags_save_string = ndr->flags;
 726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 727                         if (r->comment) {
 728                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 730                         }
 731                         ndr->flags = _flags_save_string;
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 738 {
 739         uint32_t _ptr_name;
 740         TALLOC_CTX *_mem_save_name_0;
 741         uint32_t _ptr_description;
 742         TALLOC_CTX *_mem_save_description_0;
 743         uint32_t _ptr_comment;
 744         TALLOC_CTX *_mem_save_comment_0;
 745         if (ndr_flags & NDR_SCALARS) {
 746                 NDR_CHECK(ndr_pull_align(ndr, 4));
 747                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 748                 {
 749                         uint32_t _flags_save_string = ndr->flags;
 750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 752                         if (_ptr_name) {
 753                                 NDR_PULL_ALLOC(ndr, r->name);
 754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 755                         } else {
 756                                 r->name = NULL;
 757                         }
 758                         ndr->flags = _flags_save_string;
 759                 }
 760                 {
 761                         uint32_t _flags_save_string = ndr->flags;
 762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 764                         if (_ptr_description) {
 765                                 NDR_PULL_ALLOC(ndr, r->description);
 766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 767                         } else {
 768                                 r->description = NULL;
 769                         }
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 776                         if (_ptr_comment) {
 777                                 NDR_PULL_ALLOC(ndr, r->comment);
 778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 779                         } else {
 780                                 r->comment = NULL;
 781                         }
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 uint32_t _relative_save_offset;
 791                                 _relative_save_offset = ndr->offset;
 792                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 793                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 795                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 796                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 797                                 ndr->offset = _relative_save_offset;
 798                         }
 799                         ndr->flags = _flags_save_string;
 800                 }
 801                 {
 802                         uint32_t _flags_save_string = ndr->flags;
 803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 804                         if (r->description) {
 805                                 uint32_t _relative_save_offset;
 806                                 _relative_save_offset = ndr->offset;
 807                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 808                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 809                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 810                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 811                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 812                                 ndr->offset = _relative_save_offset;
 813                         }
 814                         ndr->flags = _flags_save_string;
 815                 }
 816                 {
 817                         uint32_t _flags_save_string = ndr->flags;
 818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 819                         if (r->comment) {
 820                                 uint32_t _relative_save_offset;
 821                                 _relative_save_offset = ndr->offset;
 822                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 823                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 824                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 825                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 827                                 ndr->offset = _relative_save_offset;
 828                         }
 829                         ndr->flags = _flags_save_string;
 830                 }
 831         }
 832         return NDR_ERR_SUCCESS;
 833 }
 834
 835 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 836 {
 837         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 838         ndr->depth++;
 839         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 840         ndr_print_ptr(ndr, "name", r->name);
 841         ndr->depth++;
 842         if (r->name) {
 843                 ndr_print_string(ndr, "name", r->name);
 844         }
 845         ndr->depth--;
 846         ndr_print_ptr(ndr, "description", r->description);
 847         ndr->depth++;
 848         if (r->description) {
 849                 ndr_print_string(ndr, "description", r->description);
 850         }
 851         ndr->depth--;
 852         ndr_print_ptr(ndr, "comment", r->comment);
 853         ndr->depth++;
 854         if (r->comment) {
 855                 ndr_print_string(ndr, "comment", r->comment);
 856         }
 857         ndr->depth--;
 858         ndr->depth--;
 859 }
 860
 861 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 862 {
 863         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 868 {
 869         uint32_t v;
 870         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 871         *r = v;
 872         return NDR_ERR_SUCCESS;
 873 }
 874
 875 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 876 {
 877         ndr_print_uint32(ndr, name, r);
 878         ndr->depth++;
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 889         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 890         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 891         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 893         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 895         ndr->depth--;
 896 }
 897
 898 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 899 {
 900         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 901         return NDR_ERR_SUCCESS;
 902 }
 903
 904 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 905 {
 906         uint32_t v;
 907         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 908         *r = v;
 909         return NDR_ERR_SUCCESS;
 910 }
 911
 912 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 913 {
 914         ndr_print_uint32(ndr, name, r);
 915         ndr->depth++;
 916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 941         ndr->depth--;
 942 }
 943
 944 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 945 {
 946         if (ndr_flags & NDR_SCALARS) {
 947                 NDR_CHECK(ndr_push_align(ndr, 4));
 948                 {
 949                         uint32_t _flags_save_string = ndr->flags;
 950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 951                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 952                         ndr->flags = _flags_save_string;
 953                 }
 954                 {
 955                         uint32_t _flags_save_string = ndr->flags;
 956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 958                         ndr->flags = _flags_save_string;
 959                 }
 960                 {
 961                         uint32_t _flags_save_string = ndr->flags;
 962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 964                         ndr->flags = _flags_save_string;
 965                 }
 966                 {
 967                         uint32_t _flags_save_string = ndr->flags;
 968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
 970                         ndr->flags = _flags_save_string;
 971                 }
 972                 {
 973                         uint32_t _flags_save_string = ndr->flags;
 974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
 976                         ndr->flags = _flags_save_string;
 977                 }
 978                 {
 979                         uint32_t _flags_save_string = ndr->flags;
 980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 982                         ndr->flags = _flags_save_string;
 983                 }
 984                 {
 985                         uint32_t _flags_save_string = ndr->flags;
 986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
 988                         ndr->flags = _flags_save_string;
 989                 }
 990                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
 991                 {
 992                         uint32_t _flags_save_string = ndr->flags;
 993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 994                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
 995                         ndr->flags = _flags_save_string;
 996                 }
 997                 {
 998                         uint32_t _flags_save_string = ndr->flags;
 999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1000                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1001                         ndr->flags = _flags_save_string;
1002                 }
1003                 {
1004                         uint32_t _flags_save_string = ndr->flags;
1005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1007                         ndr->flags = _flags_save_string;
1008                 }
1009                 {
1010                         uint32_t _flags_save_string = ndr->flags;
1011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1013                         ndr->flags = _flags_save_string;
1014                 }
1015                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1016                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1021                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1024         }
1025         if (ndr_flags & NDR_BUFFERS) {
1026                 {
1027                         uint32_t _flags_save_string = ndr->flags;
1028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1029                         if (r->servername) {
1030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1032                         }
1033                         ndr->flags = _flags_save_string;
1034                 }
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         if (r->printername) {
1039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1041                         }
1042                         ndr->flags = _flags_save_string;
1043                 }
1044                 {
1045                         uint32_t _flags_save_string = ndr->flags;
1046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1047                         if (r->sharename) {
1048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1050                         }
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         if (r->portname) {
1057                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1058                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1059                         }
1060                         ndr->flags = _flags_save_string;
1061                 }
1062                 {
1063                         uint32_t _flags_save_string = ndr->flags;
1064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1065                         if (r->drivername) {
1066                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1067                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1068                         }
1069                         ndr->flags = _flags_save_string;
1070                 }
1071                 {
1072                         uint32_t _flags_save_string = ndr->flags;
1073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1074                         if (r->comment) {
1075                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1076                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1077                         }
1078                         ndr->flags = _flags_save_string;
1079                 }
1080                 {
1081                         uint32_t _flags_save_string = ndr->flags;
1082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1083                         if (r->location) {
1084                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1085                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1086                         }
1087                         ndr->flags = _flags_save_string;
1088                 }
1089                 if (r->devmode) {
1090                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1091                         {
1092                                 struct ndr_push *_ndr_devmode;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1094                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1096                         }
1097                 }
1098                 {
1099                         uint32_t _flags_save_string = ndr->flags;
1100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1101                         if (r->sepfile) {
1102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1104                         }
1105                         ndr->flags = _flags_save_string;
1106                 }
1107                 {
1108                         uint32_t _flags_save_string = ndr->flags;
1109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1110                         if (r->printprocessor) {
1111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1113                         }
1114                         ndr->flags = _flags_save_string;
1115                 }
1116                 {
1117                         uint32_t _flags_save_string = ndr->flags;
1118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1119                         if (r->datatype) {
1120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1122                         }
1123                         ndr->flags = _flags_save_string;
1124                 }
1125                 {
1126                         uint32_t _flags_save_string = ndr->flags;
1127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1128                         if (r->parameters) {
1129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1131                         }
1132                         ndr->flags = _flags_save_string;
1133                 }
1134                 if (r->secdesc) {
1135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1136                         {
1137                                 struct ndr_push *_ndr_secdesc;
1138                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1139                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1140                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1141                         }
1142                 }
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1148 {
1149         uint32_t _ptr_servername;
1150         TALLOC_CTX *_mem_save_servername_0;
1151         uint32_t _ptr_printername;
1152         TALLOC_CTX *_mem_save_printername_0;
1153         uint32_t _ptr_sharename;
1154         TALLOC_CTX *_mem_save_sharename_0;
1155         uint32_t _ptr_portname;
1156         TALLOC_CTX *_mem_save_portname_0;
1157         uint32_t _ptr_drivername;
1158         TALLOC_CTX *_mem_save_drivername_0;
1159         uint32_t _ptr_comment;
1160         TALLOC_CTX *_mem_save_comment_0;
1161         uint32_t _ptr_location;
1162         TALLOC_CTX *_mem_save_location_0;
1163         uint32_t _ptr_devmode;
1164         TALLOC_CTX *_mem_save_devmode_0;
1165         uint32_t _ptr_sepfile;
1166         TALLOC_CTX *_mem_save_sepfile_0;
1167         uint32_t _ptr_printprocessor;
1168         TALLOC_CTX *_mem_save_printprocessor_0;
1169         uint32_t _ptr_datatype;
1170         TALLOC_CTX *_mem_save_datatype_0;
1171         uint32_t _ptr_parameters;
1172         TALLOC_CTX *_mem_save_parameters_0;
1173         uint32_t _ptr_secdesc;
1174         TALLOC_CTX *_mem_save_secdesc_0;
1175         if (ndr_flags & NDR_SCALARS) {
1176                 NDR_CHECK(ndr_pull_align(ndr, 4));
1177                 {
1178                         uint32_t _flags_save_string = ndr->flags;
1179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1181                         if (_ptr_servername) {
1182                                 NDR_PULL_ALLOC(ndr, r->servername);
1183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1184                         } else {
1185                                 r->servername = NULL;
1186                         }
1187                         ndr->flags = _flags_save_string;
1188                 }
1189                 {
1190                         uint32_t _flags_save_string = ndr->flags;
1191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1193                         if (_ptr_printername) {
1194                                 NDR_PULL_ALLOC(ndr, r->printername);
1195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1196                         } else {
1197                                 r->printername = NULL;
1198                         }
1199                         ndr->flags = _flags_save_string;
1200                 }
1201                 {
1202                         uint32_t _flags_save_string = ndr->flags;
1203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1205                         if (_ptr_sharename) {
1206                                 NDR_PULL_ALLOC(ndr, r->sharename);
1207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1208                         } else {
1209                                 r->sharename = NULL;
1210                         }
1211                         ndr->flags = _flags_save_string;
1212                 }
1213                 {
1214                         uint32_t _flags_save_string = ndr->flags;
1215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1217                         if (_ptr_portname) {
1218                                 NDR_PULL_ALLOC(ndr, r->portname);
1219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1220                         } else {
1221                                 r->portname = NULL;
1222                         }
1223                         ndr->flags = _flags_save_string;
1224                 }
1225                 {
1226                         uint32_t _flags_save_string = ndr->flags;
1227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1229                         if (_ptr_drivername) {
1230                                 NDR_PULL_ALLOC(ndr, r->drivername);
1231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1232                         } else {
1233                                 r->drivername = NULL;
1234                         }
1235                         ndr->flags = _flags_save_string;
1236                 }
1237                 {
1238                         uint32_t _flags_save_string = ndr->flags;
1239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1241                         if (_ptr_comment) {
1242                                 NDR_PULL_ALLOC(ndr, r->comment);
1243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1244                         } else {
1245                                 r->comment = NULL;
1246                         }
1247                         ndr->flags = _flags_save_string;
1248                 }
1249                 {
1250                         uint32_t _flags_save_string = ndr->flags;
1251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1253                         if (_ptr_location) {
1254                                 NDR_PULL_ALLOC(ndr, r->location);
1255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1256                         } else {
1257                                 r->location = NULL;
1258                         }
1259                         ndr->flags = _flags_save_string;
1260                 }
1261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1262                 if (_ptr_devmode) {
1263                         NDR_PULL_ALLOC(ndr, r->devmode);
1264                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1265                 } else {
1266                         r->devmode = NULL;
1267                 }
1268                 {
1269                         uint32_t _flags_save_string = ndr->flags;
1270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1272                         if (_ptr_sepfile) {
1273                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1275                         } else {
1276                                 r->sepfile = NULL;
1277                         }
1278                         ndr->flags = _flags_save_string;
1279                 }
1280                 {
1281                         uint32_t _flags_save_string = ndr->flags;
1282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1284                         if (_ptr_printprocessor) {
1285                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1287                         } else {
1288                                 r->printprocessor = NULL;
1289                         }
1290                         ndr->flags = _flags_save_string;
1291                 }
1292                 {
1293                         uint32_t _flags_save_string = ndr->flags;
1294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1296                         if (_ptr_datatype) {
1297                                 NDR_PULL_ALLOC(ndr, r->datatype);
1298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1299                         } else {
1300                                 r->datatype = NULL;
1301                         }
1302                         ndr->flags = _flags_save_string;
1303                 }
1304                 {
1305                         uint32_t _flags_save_string = ndr->flags;
1306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1307                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1308                         if (_ptr_parameters) {
1309                                 NDR_PULL_ALLOC(ndr, r->parameters);
1310                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1311                         } else {
1312                                 r->parameters = NULL;
1313                         }
1314                         ndr->flags = _flags_save_string;
1315                 }
1316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1317                 if (_ptr_secdesc) {
1318                         NDR_PULL_ALLOC(ndr, r->secdesc);
1319                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1320                 } else {
1321                         r->secdesc = NULL;
1322                 }
1323                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1328                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1331         }
1332         if (ndr_flags & NDR_BUFFERS) {
1333                 {
1334                         uint32_t _flags_save_string = ndr->flags;
1335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1336                         if (r->servername) {
1337                                 uint32_t _relative_save_offset;
1338                                 _relative_save_offset = ndr->offset;
1339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1340                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1341                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1344                                 ndr->offset = _relative_save_offset;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         if (r->printername) {
1352                                 uint32_t _relative_save_offset;
1353                                 _relative_save_offset = ndr->offset;
1354                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1355                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1356                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1357                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1358                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1359                                 ndr->offset = _relative_save_offset;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 {
1364                         uint32_t _flags_save_string = ndr->flags;
1365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1366                         if (r->sharename) {
1367                                 uint32_t _relative_save_offset;
1368                                 _relative_save_offset = ndr->offset;
1369                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1370                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1371                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1372                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1373                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1374                                 ndr->offset = _relative_save_offset;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         if (r->portname) {
1382                                 uint32_t _relative_save_offset;
1383                                 _relative_save_offset = ndr->offset;
1384                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1385                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1386                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1387                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1388                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1389                                 ndr->offset = _relative_save_offset;
1390                         }
1391                         ndr->flags = _flags_save_string;
1392                 }
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->drivername) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1400                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1404                                 ndr->offset = _relative_save_offset;
1405                         }
1406                         ndr->flags = _flags_save_string;
1407                 }
1408                 {
1409                         uint32_t _flags_save_string = ndr->flags;
1410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1411                         if (r->comment) {
1412                                 uint32_t _relative_save_offset;
1413                                 _relative_save_offset = ndr->offset;
1414                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1415                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1416                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1417                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1418                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1419                                 ndr->offset = _relative_save_offset;
1420                         }
1421                         ndr->flags = _flags_save_string;
1422                 }
1423                 {
1424                         uint32_t _flags_save_string = ndr->flags;
1425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1426                         if (r->location) {
1427                                 uint32_t _relative_save_offset;
1428                                 _relative_save_offset = ndr->offset;
1429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1430                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1431                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1434                                 ndr->offset = _relative_save_offset;
1435                         }
1436                         ndr->flags = _flags_save_string;
1437                 }
1438                 if (r->devmode) {
1439                         uint32_t _relative_save_offset;
1440                         _relative_save_offset = ndr->offset;
1441                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1442                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1443                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1444                         {
1445                                 struct ndr_pull *_ndr_devmode;
1446                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1447                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1448                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1449                         }
1450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1451                         ndr->offset = _relative_save_offset;
1452                 }
1453                 {
1454                         uint32_t _flags_save_string = ndr->flags;
1455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1456                         if (r->sepfile) {
1457                                 uint32_t _relative_save_offset;
1458                                 _relative_save_offset = ndr->offset;
1459                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1460                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1461                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1462                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1463                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1464                                 ndr->offset = _relative_save_offset;
1465                         }
1466                         ndr->flags = _flags_save_string;
1467                 }
1468                 {
1469                         uint32_t _flags_save_string = ndr->flags;
1470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1471                         if (r->printprocessor) {
1472                                 uint32_t _relative_save_offset;
1473                                 _relative_save_offset = ndr->offset;
1474                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1475                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1476                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1477                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1478                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1479                                 ndr->offset = _relative_save_offset;
1480                         }
1481                         ndr->flags = _flags_save_string;
1482                 }
1483                 {
1484                         uint32_t _flags_save_string = ndr->flags;
1485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1486                         if (r->datatype) {
1487                                 uint32_t _relative_save_offset;
1488                                 _relative_save_offset = ndr->offset;
1489                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1490                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1491                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1492                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1493                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1494                                 ndr->offset = _relative_save_offset;
1495                         }
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         if (r->parameters) {
1502                                 uint32_t _relative_save_offset;
1503                                 _relative_save_offset = ndr->offset;
1504                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1505                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1506                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1507                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1508                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1509                                 ndr->offset = _relative_save_offset;
1510                         }
1511                         ndr->flags = _flags_save_string;
1512                 }
1513                 if (r->secdesc) {
1514                         uint32_t _relative_save_offset;
1515                         _relative_save_offset = ndr->offset;
1516                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1517                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1518                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1519                         {
1520                                 struct ndr_pull *_ndr_secdesc;
1521                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1522                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1523                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1524                         }
1525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1526                         ndr->offset = _relative_save_offset;
1527                 }
1528         }
1529         return NDR_ERR_SUCCESS;
1530 }
1531
1532 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1533 {
1534         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1535         ndr->depth++;
1536         ndr_print_ptr(ndr, "servername", r->servername);
1537         ndr->depth++;
1538         if (r->servername) {
1539                 ndr_print_string(ndr, "servername", r->servername);
1540         }
1541         ndr->depth--;
1542         ndr_print_ptr(ndr, "printername", r->printername);
1543         ndr->depth++;
1544         if (r->printername) {
1545                 ndr_print_string(ndr, "printername", r->printername);
1546         }
1547         ndr->depth--;
1548         ndr_print_ptr(ndr, "sharename", r->sharename);
1549         ndr->depth++;
1550         if (r->sharename) {
1551                 ndr_print_string(ndr, "sharename", r->sharename);
1552         }
1553         ndr->depth--;
1554         ndr_print_ptr(ndr, "portname", r->portname);
1555         ndr->depth++;
1556         if (r->portname) {
1557                 ndr_print_string(ndr, "portname", r->portname);
1558         }
1559         ndr->depth--;
1560         ndr_print_ptr(ndr, "drivername", r->drivername);
1561         ndr->depth++;
1562         if (r->drivername) {
1563                 ndr_print_string(ndr, "drivername", r->drivername);
1564         }
1565         ndr->depth--;
1566         ndr_print_ptr(ndr, "comment", r->comment);
1567         ndr->depth++;
1568         if (r->comment) {
1569                 ndr_print_string(ndr, "comment", r->comment);
1570         }
1571         ndr->depth--;
1572         ndr_print_ptr(ndr, "location", r->location);
1573         ndr->depth++;
1574         if (r->location) {
1575                 ndr_print_string(ndr, "location", r->location);
1576         }
1577         ndr->depth--;
1578         ndr_print_ptr(ndr, "devmode", r->devmode);
1579         ndr->depth++;
1580         if (r->devmode) {
1581                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1582         }
1583         ndr->depth--;
1584         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1585         ndr->depth++;
1586         if (r->sepfile) {
1587                 ndr_print_string(ndr, "sepfile", r->sepfile);
1588         }
1589         ndr->depth--;
1590         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1591         ndr->depth++;
1592         if (r->printprocessor) {
1593                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1594         }
1595         ndr->depth--;
1596         ndr_print_ptr(ndr, "datatype", r->datatype);
1597         ndr->depth++;
1598         if (r->datatype) {
1599                 ndr_print_string(ndr, "datatype", r->datatype);
1600         }
1601         ndr->depth--;
1602         ndr_print_ptr(ndr, "parameters", r->parameters);
1603         ndr->depth++;
1604         if (r->parameters) {
1605                 ndr_print_string(ndr, "parameters", r->parameters);
1606         }
1607         ndr->depth--;
1608         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1609         ndr->depth++;
1610         if (r->secdesc) {
1611                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1612         }
1613         ndr->depth--;
1614         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1615         ndr_print_uint32(ndr, "priority", r->priority);
1616         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1617         ndr_print_uint32(ndr, "starttime", r->starttime);
1618         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1619         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1620         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1621         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1622         ndr->depth--;
1623 }
1624
1625 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1626 {
1627         if (ndr_flags & NDR_SCALARS) {
1628                 NDR_CHECK(ndr_push_align(ndr, 4));
1629                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1630         }
1631         if (ndr_flags & NDR_BUFFERS) {
1632                 if (r->secdesc) {
1633                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1634                         {
1635                                 struct ndr_push *_ndr_secdesc;
1636                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1637                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1638                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1639                         }
1640                 }
1641         }
1642         return NDR_ERR_SUCCESS;
1643 }
1644
1645 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1646 {
1647         uint32_t _ptr_secdesc;
1648         TALLOC_CTX *_mem_save_secdesc_0;
1649         if (ndr_flags & NDR_SCALARS) {
1650                 NDR_CHECK(ndr_pull_align(ndr, 4));
1651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1652                 if (_ptr_secdesc) {
1653                         NDR_PULL_ALLOC(ndr, r->secdesc);
1654                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1655                 } else {
1656                         r->secdesc = NULL;
1657                 }
1658         }
1659         if (ndr_flags & NDR_BUFFERS) {
1660                 if (r->secdesc) {
1661                         uint32_t _relative_save_offset;
1662                         _relative_save_offset = ndr->offset;
1663                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1664                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1665                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1666                         {
1667                                 struct ndr_pull *_ndr_secdesc;
1668                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1669                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1670                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1671                         }
1672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1673                         ndr->offset = _relative_save_offset;
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1680 {
1681         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1682         ndr->depth++;
1683         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1684         ndr->depth++;
1685         if (r->secdesc) {
1686                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1687         }
1688         ndr->depth--;
1689         ndr->depth--;
1690 }
1691
1692 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1693 {
1694         if (ndr_flags & NDR_SCALARS) {
1695                 NDR_CHECK(ndr_push_align(ndr, 4));
1696                 {
1697                         uint32_t _flags_save_string = ndr->flags;
1698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1700                         ndr->flags = _flags_save_string;
1701                 }
1702                 {
1703                         uint32_t _flags_save_string = ndr->flags;
1704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1705                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1706                         ndr->flags = _flags_save_string;
1707                 }
1708                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1709         }
1710         if (ndr_flags & NDR_BUFFERS) {
1711                 {
1712                         uint32_t _flags_save_string = ndr->flags;
1713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1714                         if (r->printername) {
1715                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1716                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1717                         }
1718                         ndr->flags = _flags_save_string;
1719                 }
1720                 {
1721                         uint32_t _flags_save_string = ndr->flags;
1722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1723                         if (r->servername) {
1724                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1725                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1726                         }
1727                         ndr->flags = _flags_save_string;
1728                 }
1729         }
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1734 {
1735         uint32_t _ptr_printername;
1736         TALLOC_CTX *_mem_save_printername_0;
1737         uint32_t _ptr_servername;
1738         TALLOC_CTX *_mem_save_servername_0;
1739         if (ndr_flags & NDR_SCALARS) {
1740                 NDR_CHECK(ndr_pull_align(ndr, 4));
1741                 {
1742                         uint32_t _flags_save_string = ndr->flags;
1743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1745                         if (_ptr_printername) {
1746                                 NDR_PULL_ALLOC(ndr, r->printername);
1747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1748                         } else {
1749                                 r->printername = NULL;
1750                         }
1751                         ndr->flags = _flags_save_string;
1752                 }
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1757                         if (_ptr_servername) {
1758                                 NDR_PULL_ALLOC(ndr, r->servername);
1759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1760                         } else {
1761                                 r->servername = NULL;
1762                         }
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 uint32_t _relative_save_offset;
1773                                 _relative_save_offset = ndr->offset;
1774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1775                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1776                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1779                                 ndr->offset = _relative_save_offset;
1780                         }
1781                         ndr->flags = _flags_save_string;
1782                 }
1783                 {
1784                         uint32_t _flags_save_string = ndr->flags;
1785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1786                         if (r->servername) {
1787                                 uint32_t _relative_save_offset;
1788                                 _relative_save_offset = ndr->offset;
1789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1790                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1791                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1794                                 ndr->offset = _relative_save_offset;
1795                         }
1796                         ndr->flags = _flags_save_string;
1797                 }
1798         }
1799         return NDR_ERR_SUCCESS;
1800 }
1801
1802 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1803 {
1804         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1805         ndr->depth++;
1806         ndr_print_ptr(ndr, "printername", r->printername);
1807         ndr->depth++;
1808         if (r->printername) {
1809                 ndr_print_string(ndr, "printername", r->printername);
1810         }
1811         ndr->depth--;
1812         ndr_print_ptr(ndr, "servername", r->servername);
1813         ndr->depth++;
1814         if (r->servername) {
1815                 ndr_print_string(ndr, "servername", r->servername);
1816         }
1817         ndr->depth--;
1818         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1819         ndr->depth--;
1820 }
1821
1822 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1823 {
1824         if (ndr_flags & NDR_SCALARS) {
1825                 NDR_CHECK(ndr_push_align(ndr, 4));
1826                 {
1827                         uint32_t _flags_save_string = ndr->flags;
1828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1830                         ndr->flags = _flags_save_string;
1831                 }
1832                 {
1833                         uint32_t _flags_save_string = ndr->flags;
1834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1841         }
1842         if (ndr_flags & NDR_BUFFERS) {
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         if (r->printername) {
1847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1848                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1849                         }
1850                         ndr->flags = _flags_save_string;
1851                 }
1852                 {
1853                         uint32_t _flags_save_string = ndr->flags;
1854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1855                         if (r->portname) {
1856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1858                         }
1859                         ndr->flags = _flags_save_string;
1860                 }
1861         }
1862         return NDR_ERR_SUCCESS;
1863 }
1864
1865 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1866 {
1867         uint32_t _ptr_printername;
1868         TALLOC_CTX *_mem_save_printername_0;
1869         uint32_t _ptr_portname;
1870         TALLOC_CTX *_mem_save_portname_0;
1871         if (ndr_flags & NDR_SCALARS) {
1872                 NDR_CHECK(ndr_pull_align(ndr, 4));
1873                 {
1874                         uint32_t _flags_save_string = ndr->flags;
1875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1877                         if (_ptr_printername) {
1878                                 NDR_PULL_ALLOC(ndr, r->printername);
1879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1880                         } else {
1881                                 r->printername = NULL;
1882                         }
1883                         ndr->flags = _flags_save_string;
1884                 }
1885                 {
1886                         uint32_t _flags_save_string = ndr->flags;
1887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1889                         if (_ptr_portname) {
1890                                 NDR_PULL_ALLOC(ndr, r->portname);
1891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1892                         } else {
1893                                 r->portname = NULL;
1894                         }
1895                         ndr->flags = _flags_save_string;
1896                 }
1897                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 {
1903                         uint32_t _flags_save_string = ndr->flags;
1904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1905                         if (r->printername) {
1906                                 uint32_t _relative_save_offset;
1907                                 _relative_save_offset = ndr->offset;
1908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1909                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1910                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1913                                 ndr->offset = _relative_save_offset;
1914                         }
1915                         ndr->flags = _flags_save_string;
1916                 }
1917                 {
1918                         uint32_t _flags_save_string = ndr->flags;
1919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1920                         if (r->portname) {
1921                                 uint32_t _relative_save_offset;
1922                                 _relative_save_offset = ndr->offset;
1923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1924                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1925                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1928                                 ndr->offset = _relative_save_offset;
1929                         }
1930                         ndr->flags = _flags_save_string;
1931                 }
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1937 {
1938         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1939         ndr->depth++;
1940         ndr_print_ptr(ndr, "printername", r->printername);
1941         ndr->depth++;
1942         if (r->printername) {
1943                 ndr_print_string(ndr, "printername", r->printername);
1944         }
1945         ndr->depth--;
1946         ndr_print_ptr(ndr, "portname", r->portname);
1947         ndr->depth++;
1948         if (r->portname) {
1949                 ndr_print_string(ndr, "portname", r->portname);
1950         }
1951         ndr->depth--;
1952         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1953         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1954         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1955         ndr->depth--;
1956 }
1957
1958 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1959 {
1960         if (ndr_flags & NDR_SCALARS) {
1961                 NDR_CHECK(ndr_push_align(ndr, 4));
1962                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1963         }
1964         if (ndr_flags & NDR_BUFFERS) {
1965         }
1966         return NDR_ERR_SUCCESS;
1967 }
1968
1969 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
1970 {
1971         if (ndr_flags & NDR_SCALARS) {
1972                 NDR_CHECK(ndr_pull_align(ndr, 4));
1973                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976         }
1977         return NDR_ERR_SUCCESS;
1978 }
1979
1980 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
1981 {
1982         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
1983         ndr->depth++;
1984         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1985         ndr->depth--;
1986 }
1987
1988 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1989 {
1990         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1991         return NDR_ERR_SUCCESS;
1992 }
1993
1994 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1995 {
1996         uint32_t v;
1997         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1998         *r = v;
1999         return NDR_ERR_SUCCESS;
2000 }
2001
2002 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2003 {
2004         ndr_print_uint32(ndr, name, r);
2005         ndr->depth++;
2006         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2007         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2008         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2009         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2010         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2011         ndr->depth--;
2012 }
2013
2014 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2015 {
2016         if (ndr_flags & NDR_SCALARS) {
2017                 NDR_CHECK(ndr_push_align(ndr, 4));
2018                 {
2019                         uint32_t _flags_save_string = ndr->flags;
2020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2022                         ndr->flags = _flags_save_string;
2023                 }
2024                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2025         }
2026         if (ndr_flags & NDR_BUFFERS) {
2027                 {
2028                         uint32_t _flags_save_string = ndr->flags;
2029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2030                         if (r->guid) {
2031                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2032                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2033                         }
2034                         ndr->flags = _flags_save_string;
2035                 }
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2041 {
2042         uint32_t _ptr_guid;
2043         TALLOC_CTX *_mem_save_guid_0;
2044         if (ndr_flags & NDR_SCALARS) {
2045                 NDR_CHECK(ndr_pull_align(ndr, 4));
2046                 {
2047                         uint32_t _flags_save_string = ndr->flags;
2048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2050                         if (_ptr_guid) {
2051                                 NDR_PULL_ALLOC(ndr, r->guid);
2052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2053                         } else {
2054                                 r->guid = NULL;
2055                         }
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 uint32_t _relative_save_offset;
2066                                 _relative_save_offset = ndr->offset;
2067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2068                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2069                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2072                                 ndr->offset = _relative_save_offset;
2073                         }
2074                         ndr->flags = _flags_save_string;
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2081 {
2082         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2083         ndr->depth++;
2084         ndr_print_ptr(ndr, "guid", r->guid);
2085         ndr->depth++;
2086         if (r->guid) {
2087                 ndr_print_string(ndr, "guid", r->guid);
2088         }
2089         ndr->depth--;
2090         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2091         ndr->depth--;
2092 }
2093
2094 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2095 {
2096         if (ndr_flags & NDR_SCALARS) {
2097                 NDR_CHECK(ndr_push_align(ndr, 4));
2098                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2099         }
2100         if (ndr_flags & NDR_BUFFERS) {
2101                 if (r->devmode) {
2102                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2103                         {
2104                                 struct ndr_push *_ndr_devmode;
2105                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2106                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2107                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2108                         }
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2115 {
2116         uint32_t _ptr_devmode;
2117         TALLOC_CTX *_mem_save_devmode_0;
2118         if (ndr_flags & NDR_SCALARS) {
2119                 NDR_CHECK(ndr_pull_align(ndr, 4));
2120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2121                 if (_ptr_devmode) {
2122                         NDR_PULL_ALLOC(ndr, r->devmode);
2123                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2124                 } else {
2125                         r->devmode = NULL;
2126                 }
2127         }
2128         if (ndr_flags & NDR_BUFFERS) {
2129                 if (r->devmode) {
2130                         uint32_t _relative_save_offset;
2131                         _relative_save_offset = ndr->offset;
2132                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2133                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2134                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2135                         {
2136                                 struct ndr_pull *_ndr_devmode;
2137                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2138                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2139                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2140                         }
2141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2142                         ndr->offset = _relative_save_offset;
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2149 {
2150         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2151         ndr->depth++;
2152         ndr_print_ptr(ndr, "devmode", r->devmode);
2153         ndr->depth++;
2154         if (r->devmode) {
2155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2156         }
2157         ndr->depth--;
2158         ndr->depth--;
2159 }
2160
2161 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2162 {
2163         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2164         if (ndr_flags & NDR_SCALARS) {
2165                 int level = ndr_push_get_switch_value(ndr, r);
2166                 switch (level) {
2167                         case 0: {
2168                                 NDR_CHECK(ndr_push_align(ndr, 4));
2169                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2170                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2171                         break; }
2172
2173                         case 1: {
2174                                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2176                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2177                         break; }
2178
2179                         case 2: {
2180                                 NDR_CHECK(ndr_push_align(ndr, 4));
2181                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2182                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2183                         break; }
2184
2185                         case 3: {
2186                                 NDR_CHECK(ndr_push_align(ndr, 4));
2187                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2188                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2189                         break; }
2190
2191                         case 4: {
2192                                 NDR_CHECK(ndr_push_align(ndr, 4));
2193                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2194                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2195                         break; }
2196
2197                         case 5: {
2198                                 NDR_CHECK(ndr_push_align(ndr, 4));
2199                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2200                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2201                         break; }
2202
2203                         case 6: {
2204                                 NDR_CHECK(ndr_push_align(ndr, 4));
2205                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2206                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2207                         break; }
2208
2209                         case 7: {
2210                                 NDR_CHECK(ndr_push_align(ndr, 4));
2211                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2212                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2213                         break; }
2214
2215                         case 8: {
2216                                 NDR_CHECK(ndr_push_align(ndr, 4));
2217                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2218                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2219                         break; }
2220
2221                         case 9: {
2222                                 NDR_CHECK(ndr_push_align(ndr, 4));
2223                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2224                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2225                         break; }
2226
2227                         default: {
2228                         break; }
2229
2230                 }
2231         }
2232         if (ndr_flags & NDR_BUFFERS) {
2233                 int level = ndr_push_get_switch_value(ndr, r);
2234                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2235                 switch (level) {
2236                         case 0:
2237                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2238                         break;
2239
2240                         case 1:
2241                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2242                         break;
2243
2244                         case 2:
2245                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2246                         break;
2247
2248                         case 3:
2249                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2250                         break;
2251
2252                         case 4:
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2254                         break;
2255
2256                         case 5:
2257                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2258                         break;
2259
2260                         case 6:
2261                         break;
2262
2263                         case 7:
2264                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2265                         break;
2266
2267                         case 8:
2268                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2269                         break;
2270
2271                         case 9:
2272                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2273                         break;
2274
2275                         default:
2276                         break;
2277
2278                 }
2279         }
2280         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2281         return NDR_ERR_SUCCESS;
2282 }
2283
2284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2285 {
2286         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2287         int level;
2288         level = ndr_pull_get_switch_value(ndr, r);
2289         if (ndr_flags & NDR_SCALARS) {
2290                 switch (level) {
2291                         case 0: {
2292                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2293                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2294                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2295                         break; }
2296
2297                         case 1: {
2298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2300                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2301                         break; }
2302
2303                         case 2: {
2304                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2305                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2306                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2307                         break; }
2308
2309                         case 3: {
2310                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2311                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2312                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2313                         break; }
2314
2315                         case 4: {
2316                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2317                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2318                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2319                         break; }
2320
2321                         case 5: {
2322                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2323                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2324                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2325                         break; }
2326
2327                         case 6: {
2328                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2329                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2330                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2331                         break; }
2332
2333                         case 7: {
2334                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2335                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2336                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2337                         break; }
2338
2339                         case 8: {
2340                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2341                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2342                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2343                         break; }
2344
2345                         case 9: {
2346                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2347                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2348                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2349                         break; }
2350
2351                         default: {
2352                         break; }
2353
2354                 }
2355         }
2356         if (ndr_flags & NDR_BUFFERS) {
2357                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2358                 switch (level) {
2359                         case 0:
2360                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2361                         break;
2362
2363                         case 1:
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2365                         break;
2366
2367                         case 2:
2368                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2369                         break;
2370
2371                         case 3:
2372                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2373                         break;
2374
2375                         case 4:
2376                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2377                         break;
2378
2379                         case 5:
2380                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2381                         break;
2382
2383                         case 6:
2384                         break;
2385
2386                         case 7:
2387                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2388                         break;
2389
2390                         case 8:
2391                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2392                         break;
2393
2394                         case 9:
2395                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2396                         break;
2397
2398                         default:
2399                         break;
2400
2401                 }
2402         }
2403         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2408 {
2409         int level;
2410         level = ndr_print_get_switch_value(ndr, r);
2411         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2412         switch (level) {
2413                 case 0:
2414                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2415                 break;
2416
2417                 case 1:
2418                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2419                 break;
2420
2421                 case 2:
2422                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2423                 break;
2424
2425                 case 3:
2426                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2427                 break;
2428
2429                 case 4:
2430                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2431                 break;
2432
2433                 case 5:
2434                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2435                 break;
2436
2437                 case 6:
2438                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2439                 break;
2440
2441                 case 7:
2442                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2443                 break;
2444
2445                 case 8:
2446                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2447                 break;
2448
2449                 case 9:
2450                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2451                 break;
2452
2453                 default:
2454                 break;
2455
2456         }
2457 }
2458
2459 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2460 {
2461         if (ndr_flags & NDR_SCALARS) {
2462                 NDR_CHECK(ndr_push_align(ndr, 4));
2463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2465         }
2466         if (ndr_flags & NDR_BUFFERS) {
2467                 if (r->devmode) {
2468                         {
2469                                 struct ndr_push *_ndr_devmode;
2470                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2471                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2472                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2473                         }
2474                 }
2475         }
2476         return NDR_ERR_SUCCESS;
2477 }
2478
2479 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2480 {
2481         uint32_t _ptr_devmode;
2482         TALLOC_CTX *_mem_save_devmode_0;
2483         if (ndr_flags & NDR_SCALARS) {
2484                 NDR_CHECK(ndr_pull_align(ndr, 4));
2485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2487                 if (_ptr_devmode) {
2488                         NDR_PULL_ALLOC(ndr, r->devmode);
2489                 } else {
2490                         r->devmode = NULL;
2491                 }
2492         }
2493         if (ndr_flags & NDR_BUFFERS) {
2494                 if (r->devmode) {
2495                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2497                         {
2498                                 struct ndr_pull *_ndr_devmode;
2499                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2500                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2501                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2502                         }
2503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2504                 }
2505         }
2506         return NDR_ERR_SUCCESS;
2507 }
2508
2509 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2510 {
2511         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2512         ndr->depth++;
2513         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2514         ndr_print_ptr(ndr, "devmode", r->devmode);
2515         ndr->depth++;
2516         if (r->devmode) {
2517                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2518         }
2519         ndr->depth--;
2520         ndr->depth--;
2521 }
2522
2523 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2524 {
2525         if (ndr_flags & NDR_SCALARS) {
2526                 NDR_CHECK(ndr_push_align(ndr, 4));
2527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2528                 {
2529                         uint32_t _flags_save_string = ndr->flags;
2530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2532                         ndr->flags = _flags_save_string;
2533                 }
2534                 {
2535                         uint32_t _flags_save_string = ndr->flags;
2536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2538                         ndr->flags = _flags_save_string;
2539                 }
2540                 {
2541                         uint32_t _flags_save_string = ndr->flags;
2542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2544                         ndr->flags = _flags_save_string;
2545                 }
2546                 {
2547                         uint32_t _flags_save_string = ndr->flags;
2548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2550                         ndr->flags = _flags_save_string;
2551                 }
2552                 {
2553                         uint32_t _flags_save_string = ndr->flags;
2554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2556                         ndr->flags = _flags_save_string;
2557                 }
2558                 {
2559                         uint32_t _flags_save_string = ndr->flags;
2560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2562                         ndr->flags = _flags_save_string;
2563                 }
2564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
2565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2569                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2570         }
2571         if (ndr_flags & NDR_BUFFERS) {
2572                 {
2573                         uint32_t _flags_save_string = ndr->flags;
2574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2575                         if (r->printer_name) {
2576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2578                         }
2579                         ndr->flags = _flags_save_string;
2580                 }
2581                 {
2582                         uint32_t _flags_save_string = ndr->flags;
2583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2584                         if (r->server_name) {
2585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2587                         }
2588                         ndr->flags = _flags_save_string;
2589                 }
2590                 {
2591                         uint32_t _flags_save_string = ndr->flags;
2592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2593                         if (r->user_name) {
2594                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2596                         }
2597                         ndr->flags = _flags_save_string;
2598                 }
2599                 {
2600                         uint32_t _flags_save_string = ndr->flags;
2601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2602                         if (r->document_name) {
2603                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2605                         }
2606                         ndr->flags = _flags_save_string;
2607                 }
2608                 {
2609                         uint32_t _flags_save_string = ndr->flags;
2610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2611                         if (r->data_type) {
2612                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2613                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2614                         }
2615                         ndr->flags = _flags_save_string;
2616                 }
2617                 {
2618                         uint32_t _flags_save_string = ndr->flags;
2619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2620                         if (r->text_status) {
2621                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2622                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2623                         }
2624                         ndr->flags = _flags_save_string;
2625                 }
2626         }
2627         return NDR_ERR_SUCCESS;
2628 }
2629
2630 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2631 {
2632         uint32_t _ptr_printer_name;
2633         TALLOC_CTX *_mem_save_printer_name_0;
2634         uint32_t _ptr_server_name;
2635         TALLOC_CTX *_mem_save_server_name_0;
2636         uint32_t _ptr_user_name;
2637         TALLOC_CTX *_mem_save_user_name_0;
2638         uint32_t _ptr_document_name;
2639         TALLOC_CTX *_mem_save_document_name_0;
2640         uint32_t _ptr_data_type;
2641         TALLOC_CTX *_mem_save_data_type_0;
2642         uint32_t _ptr_text_status;
2643         TALLOC_CTX *_mem_save_text_status_0;
2644         if (ndr_flags & NDR_SCALARS) {
2645                 NDR_CHECK(ndr_pull_align(ndr, 4));
2646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2647                 {
2648                         uint32_t _flags_save_string = ndr->flags;
2649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2651                         if (_ptr_printer_name) {
2652                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2654                         } else {
2655                                 r->printer_name = NULL;
2656                         }
2657                         ndr->flags = _flags_save_string;
2658                 }
2659                 {
2660                         uint32_t _flags_save_string = ndr->flags;
2661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2663                         if (_ptr_server_name) {
2664                                 NDR_PULL_ALLOC(ndr, r->server_name);
2665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2666                         } else {
2667                                 r->server_name = NULL;
2668                         }
2669                         ndr->flags = _flags_save_string;
2670                 }
2671                 {
2672                         uint32_t _flags_save_string = ndr->flags;
2673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2675                         if (_ptr_user_name) {
2676                                 NDR_PULL_ALLOC(ndr, r->user_name);
2677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2678                         } else {
2679                                 r->user_name = NULL;
2680                         }
2681                         ndr->flags = _flags_save_string;
2682                 }
2683                 {
2684                         uint32_t _flags_save_string = ndr->flags;
2685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2687                         if (_ptr_document_name) {
2688                                 NDR_PULL_ALLOC(ndr, r->document_name);
2689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2690                         } else {
2691                                 r->document_name = NULL;
2692                         }
2693                         ndr->flags = _flags_save_string;
2694                 }
2695                 {
2696                         uint32_t _flags_save_string = ndr->flags;
2697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2699                         if (_ptr_data_type) {
2700                                 NDR_PULL_ALLOC(ndr, r->data_type);
2701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2702                         } else {
2703                                 r->data_type = NULL;
2704                         }
2705                         ndr->flags = _flags_save_string;
2706                 }
2707                 {
2708                         uint32_t _flags_save_string = ndr->flags;
2709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2710                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2711                         if (_ptr_text_status) {
2712                                 NDR_PULL_ALLOC(ndr, r->text_status);
2713                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2714                         } else {
2715                                 r->text_status = NULL;
2716                         }
2717                         ndr->flags = _flags_save_string;
2718                 }
2719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
2720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2724                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2725         }
2726         if (ndr_flags & NDR_BUFFERS) {
2727                 {
2728                         uint32_t _flags_save_string = ndr->flags;
2729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2730                         if (r->printer_name) {
2731                                 uint32_t _relative_save_offset;
2732                                 _relative_save_offset = ndr->offset;
2733                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2734                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2735                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2736                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2737                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2738                                 ndr->offset = _relative_save_offset;
2739                         }
2740                         ndr->flags = _flags_save_string;
2741                 }
2742                 {
2743                         uint32_t _flags_save_string = ndr->flags;
2744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2745                         if (r->server_name) {
2746                                 uint32_t _relative_save_offset;
2747                                 _relative_save_offset = ndr->offset;
2748                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2749                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2750                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2751                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2752                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2753                                 ndr->offset = _relative_save_offset;
2754                         }
2755                         ndr->flags = _flags_save_string;
2756                 }
2757                 {
2758                         uint32_t _flags_save_string = ndr->flags;
2759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2760                         if (r->user_name) {
2761                                 uint32_t _relative_save_offset;
2762                                 _relative_save_offset = ndr->offset;
2763                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2764                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2765                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2766                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2767                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2768                                 ndr->offset = _relative_save_offset;
2769                         }
2770                         ndr->flags = _flags_save_string;
2771                 }
2772                 {
2773                         uint32_t _flags_save_string = ndr->flags;
2774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2775                         if (r->document_name) {
2776                                 uint32_t _relative_save_offset;
2777                                 _relative_save_offset = ndr->offset;
2778                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2779                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2780                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2781                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2782                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2783                                 ndr->offset = _relative_save_offset;
2784                         }
2785                         ndr->flags = _flags_save_string;
2786                 }
2787                 {
2788                         uint32_t _flags_save_string = ndr->flags;
2789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2790                         if (r->data_type) {
2791                                 uint32_t _relative_save_offset;
2792                                 _relative_save_offset = ndr->offset;
2793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2794                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2795                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2798                                 ndr->offset = _relative_save_offset;
2799                         }
2800                         ndr->flags = _flags_save_string;
2801                 }
2802                 {
2803                         uint32_t _flags_save_string = ndr->flags;
2804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2805                         if (r->text_status) {
2806                                 uint32_t _relative_save_offset;
2807                                 _relative_save_offset = ndr->offset;
2808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2809                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2810                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2813                                 ndr->offset = _relative_save_offset;
2814                         }
2815                         ndr->flags = _flags_save_string;
2816                 }
2817         }
2818         return NDR_ERR_SUCCESS;
2819 }
2820
2821 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2822 {
2823         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2824         ndr->depth++;
2825         ndr_print_uint32(ndr, "job_id", r->job_id);
2826         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2827         ndr->depth++;
2828         if (r->printer_name) {
2829                 ndr_print_string(ndr, "printer_name", r->printer_name);
2830         }
2831         ndr->depth--;
2832         ndr_print_ptr(ndr, "server_name", r->server_name);
2833         ndr->depth++;
2834         if (r->server_name) {
2835                 ndr_print_string(ndr, "server_name", r->server_name);
2836         }
2837         ndr->depth--;
2838         ndr_print_ptr(ndr, "user_name", r->user_name);
2839         ndr->depth++;
2840         if (r->user_name) {
2841                 ndr_print_string(ndr, "user_name", r->user_name);
2842         }
2843         ndr->depth--;
2844         ndr_print_ptr(ndr, "document_name", r->document_name);
2845         ndr->depth++;
2846         if (r->document_name) {
2847                 ndr_print_string(ndr, "document_name", r->document_name);
2848         }
2849         ndr->depth--;
2850         ndr_print_ptr(ndr, "data_type", r->data_type);
2851         ndr->depth++;
2852         if (r->data_type) {
2853                 ndr_print_string(ndr, "data_type", r->data_type);
2854         }
2855         ndr->depth--;
2856         ndr_print_ptr(ndr, "text_status", r->text_status);
2857         ndr->depth++;
2858         if (r->text_status) {
2859                 ndr_print_string(ndr, "text_status", r->text_status);
2860         }
2861         ndr->depth--;
2862         ndr_print_uint32(ndr, "status", r->status);
2863         ndr_print_uint32(ndr, "priority", r->priority);
2864         ndr_print_uint32(ndr, "position", r->position);
2865         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2866         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2867         ndr_print_spoolss_Time(ndr, "time", &r->time);
2868         ndr->depth--;
2869 }
2870
2871 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
2872 {
2873         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2874         if (ndr_flags & NDR_SCALARS) {
2875                 int level = ndr_push_get_switch_value(ndr, r);
2876                 switch (level) {
2877                         case 1: {
2878                                 NDR_CHECK(ndr_push_align(ndr, 4));
2879                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2880                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2881                         break; }
2882
2883                         case 2: {
2884                         break; }
2885
2886                         case 3: {
2887                         break; }
2888
2889                         default: {
2890                         break; }
2891
2892                 }
2893         }
2894         if (ndr_flags & NDR_BUFFERS) {
2895                 int level = ndr_push_get_switch_value(ndr, r);
2896                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2897                 switch (level) {
2898                         case 1:
2899                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2900                         break;
2901
2902                         case 2:
2903                         break;
2904
2905                         case 3:
2906                         break;
2907
2908                         default:
2909                         break;
2910
2911                 }
2912         }
2913         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2914         return NDR_ERR_SUCCESS;
2915 }
2916
2917 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
2918 {
2919         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2920         int level;
2921         level = ndr_pull_get_switch_value(ndr, r);
2922         if (ndr_flags & NDR_SCALARS) {
2923                 switch (level) {
2924                         case 1: {
2925                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2926                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2927                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2928                         break; }
2929
2930                         case 2: {
2931                         break; }
2932
2933                         case 3: {
2934                         break; }
2935
2936                         default: {
2937                         break; }
2938
2939                 }
2940         }
2941         if (ndr_flags & NDR_BUFFERS) {
2942                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2943                 switch (level) {
2944                         case 1:
2945                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2946                         break;
2947
2948                         case 2:
2949                         break;
2950
2951                         case 3:
2952                         break;
2953
2954                         default:
2955                         break;
2956
2957                 }
2958         }
2959         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2960         return NDR_ERR_SUCCESS;
2961 }
2962
2963 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
2964 {
2965         int level;
2966         level = ndr_print_get_switch_value(ndr, r);
2967         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
2968         switch (level) {
2969                 case 1:
2970                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
2971                 break;
2972
2973                 case 2:
2974                 break;
2975
2976                 case 3:
2977                 break;
2978
2979                 default:
2980                 break;
2981
2982         }
2983 }
2984
2985 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
2986 {
2987         if (ndr_flags & NDR_SCALARS) {
2988                 NDR_CHECK(ndr_push_align(ndr, 4));
2989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2990                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
2991                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
2992         }
2993         if (ndr_flags & NDR_BUFFERS) {
2994                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
2995         }
2996         return NDR_ERR_SUCCESS;
2997 }
2998
2999 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
3000 {
3001         if (ndr_flags & NDR_SCALARS) {
3002                 NDR_CHECK(ndr_pull_align(ndr, 4));
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3004                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
3005                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
3009         }
3010         return NDR_ERR_SUCCESS;
3011 }
3012
3013 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
3014 {
3015         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
3016         ndr->depth++;
3017         ndr_print_uint32(ndr, "level", r->level);
3018         ndr_print_set_switch_value(ndr, &r->info, r->level);
3019         ndr_print_spoolss_JobInfo(ndr, "info", &r->info);
3020         ndr->depth--;
3021 }
3022
3023 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
3024 {
3025         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3026         return NDR_ERR_SUCCESS;
3027 }
3028
3029 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
3030 {
3031         uint32_t v;
3032         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3033         *r = v;
3034         return NDR_ERR_SUCCESS;
3035 }
3036
3037 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
3038 {
3039         const char *val = NULL;
3040
3041         switch (r) {
3042                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
3043                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
3044                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
3045                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
3046                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
3047                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
3048                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
3049         }
3050         ndr_print_enum(ndr, name, "ENUM", val, r);
3051 }
3052
3053 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
3054 {
3055         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3056         return NDR_ERR_SUCCESS;
3057 }
3058
3059 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
3060 {
3061         uint32_t v;
3062         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3063         *r = v;
3064         return NDR_ERR_SUCCESS;
3065 }
3066
3067 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
3068 {
3069         const char *val = NULL;
3070
3071         switch (r) {
3072                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
3073                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
3074                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
3075                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
3076                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
3077         }
3078         ndr_print_enum(ndr, name, "ENUM", val, r);
3079 }
3080
3081 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
3082 {
3083         if (ndr_flags & NDR_SCALARS) {
3084                 NDR_CHECK(ndr_push_align(ndr, 4));
3085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
3089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
3090                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
3092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
3094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
3095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
3096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
3097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
3098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
3099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
3100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
3101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
3102                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
3103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
3104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
3105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
3106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
3107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
3108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
3109                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
3110                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
3111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
3112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
3113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
3114         }
3115         if (ndr_flags & NDR_BUFFERS) {
3116                 if (r->servername) {
3117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3121                 }
3122                 if (r->printername) {
3123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
3133 {
3134         uint32_t _ptr_servername;
3135         TALLOC_CTX *_mem_save_servername_0;
3136         uint32_t _ptr_printername;
3137         TALLOC_CTX *_mem_save_printername_0;
3138         if (ndr_flags & NDR_SCALARS) {
3139                 NDR_CHECK(ndr_pull_align(ndr, 4));
3140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3141                 if (_ptr_servername) {
3142                         NDR_PULL_ALLOC(ndr, r->servername);
3143                 } else {
3144                         r->servername = NULL;
3145                 }
3146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3147                 if (_ptr_printername) {
3148                         NDR_PULL_ALLOC(ndr, r->printername);
3149                 } else {
3150                         r->printername = NULL;
3151                 }
3152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
3154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
3155                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
3157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
3159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
3160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
3161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
3162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
3163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
3164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
3165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
3166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
3167                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
3168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
3169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
3170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
3171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
3172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
3173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
3174                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
3175                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
3176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
3177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
3178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
3179         }
3180         if (ndr_flags & NDR_BUFFERS) {
3181                 if (r->servername) {
3182                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3183                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3186                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3187                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3188                         }
3189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3192                 }
3193                 if (r->printername) {
3194                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3195                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3198                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3200                         }
3201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3204                 }
3205         }
3206         return NDR_ERR_SUCCESS;
3207 }
3208
3209 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
3210 {
3211         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
3212         ndr->depth++;
3213         ndr_print_ptr(ndr, "servername", r->servername);
3214         ndr->depth++;
3215         if (r->servername) {
3216                 ndr_print_string(ndr, "servername", r->servername);
3217         }
3218         ndr->depth--;
3219         ndr_print_ptr(ndr, "printername", r->printername);
3220         ndr->depth++;
3221         if (r->printername) {
3222                 ndr_print_string(ndr, "printername", r->printername);
3223         }
3224         ndr->depth--;
3225         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3226         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
3227         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
3228         ndr_print_spoolss_Time(ndr, "time", &r->time);
3229         ndr_print_uint32(ndr, "global_counter", r->global_counter);
3230         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3231         ndr_print_uint32(ndr, "version", r->version);
3232         ndr_print_uint32(ndr, "free_build", r->free_build);
3233         ndr_print_uint32(ndr, "spooling", r->spooling);
3234         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
3235         ndr_print_uint32(ndr, "session_counter", r->session_counter);
3236         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
3237         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
3238         ndr_print_uint32(ndr, "job_error", r->job_error);
3239         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
3240         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
3241         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
3242         ndr_print_uint32(ndr, "change_id", r->change_id);
3243         ndr_print_WERROR(ndr, "last_error", r->last_error);
3244         ndr_print_uint32(ndr, "status", r->status);
3245         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
3246         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
3247         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
3248         ndr_print_uint16(ndr, "processor_level", r->processor_level);
3249         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
3250         ndr_print_uint32(ndr, "reserved2", r->reserved2);
3251         ndr_print_uint32(ndr, "reserved3", r->reserved3);
3252         ndr->depth--;
3253 }
3254
3255 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
3256 {
3257         if (ndr_flags & NDR_SCALARS) {
3258                 NDR_CHECK(ndr_push_align(ndr, 4));
3259                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
3260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
3262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3263         }
3264         if (ndr_flags & NDR_BUFFERS) {
3265                 if (r->name) {
3266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3270                 }
3271                 if (r->description) {
3272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3276                 }
3277                 if (r->comment) {
3278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3282                 }
3283         }
3284         return NDR_ERR_SUCCESS;
3285 }
3286
3287 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
3288 {
3289         uint32_t _ptr_name;
3290         TALLOC_CTX *_mem_save_name_0;
3291         uint32_t _ptr_description;
3292         TALLOC_CTX *_mem_save_description_0;
3293         uint32_t _ptr_comment;
3294         TALLOC_CTX *_mem_save_comment_0;
3295         if (ndr_flags & NDR_SCALARS) {
3296                 NDR_CHECK(ndr_pull_align(ndr, 4));
3297                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3299                 if (_ptr_name) {
3300                         NDR_PULL_ALLOC(ndr, r->name);
3301                 } else {
3302                         r->name = NULL;
3303                 }
3304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
3305                 if (_ptr_description) {
3306                         NDR_PULL_ALLOC(ndr, r->description);
3307                 } else {
3308                         r->description = NULL;
3309                 }
3310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3311                 if (_ptr_comment) {
3312                         NDR_PULL_ALLOC(ndr, r->comment);
3313                 } else {
3314                         r->comment = NULL;
3315                 }
3316         }
3317         if (ndr_flags & NDR_BUFFERS) {
3318                 if (r->name) {
3319                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3320                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3323                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3324                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3325                         }
3326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3329                 }
3330                 if (r->description) {
3331                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
3332                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
3333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
3334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
3335                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
3336                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
3337                         }
3338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
3339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
3340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
3341                 }
3342                 if (r->comment) {
3343                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3347                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3349                         }
3350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3353                 }
3354         }
3355         return NDR_ERR_SUCCESS;
3356 }
3357
3358 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
3359 {
3360         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
3361         ndr->depth++;
3362         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
3363         ndr_print_ptr(ndr, "name", r->name);
3364         ndr->depth++;
3365         if (r->name) {
3366                 ndr_print_string(ndr, "name", r->name);
3367         }
3368         ndr->depth--;
3369         ndr_print_ptr(ndr, "description", r->description);
3370         ndr->depth++;
3371         if (r->description) {
3372                 ndr_print_string(ndr, "description", r->description);
3373         }
3374         ndr->depth--;
3375         ndr_print_ptr(ndr, "comment", r->comment);
3376         ndr->depth++;
3377         if (r->comment) {
3378                 ndr_print_string(ndr, "comment", r->comment);
3379         }
3380         ndr->depth--;
3381         ndr->depth--;
3382 }
3383
3384 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
3385 {
3386         if (ndr_flags & NDR_SCALARS) {
3387                 NDR_CHECK(ndr_push_align(ndr, 4));
3388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
3391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
3392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
3393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
3395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
3397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
3398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
3399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
3400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3401                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
3404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
3405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
3406                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
3407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
3409         }
3410         if (ndr_flags & NDR_BUFFERS) {
3411                 if (r->servername) {
3412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3416                 }
3417                 if (r->printername) {
3418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3422                 }
3423                 if (r->sharename) {
3424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3428                 }
3429                 if (r->portname) {
3430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3434                 }
3435                 if (r->drivername) {
3436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3440                 }
3441                 if (r->comment) {
3442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3446                 }
3447                 if (r->location) {
3448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3452                 }
3453                 if (r->devmode) {
3454                         {
3455                                 struct ndr_push *_ndr_devmode;
3456                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3457                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3458                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3459                         }
3460                 }
3461                 if (r->sepfile) {
3462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3465                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3466                 }
3467                 if (r->printprocessor) {
3468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3472                 }
3473                 if (r->datatype) {
3474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3478                 }
3479                 if (r->parameters) {
3480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3484                 }
3485                 if (r->secdesc) {
3486                         {
3487                                 struct ndr_push *_ndr_secdesc;
3488                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3489                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3490                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3491                         }
3492                 }
3493         }
3494         return NDR_ERR_SUCCESS;
3495 }
3496
3497 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
3498 {
3499         uint32_t _ptr_servername;
3500         TALLOC_CTX *_mem_save_servername_0;
3501         uint32_t _ptr_printername;
3502         TALLOC_CTX *_mem_save_printername_0;
3503         uint32_t _ptr_sharename;
3504         TALLOC_CTX *_mem_save_sharename_0;
3505         uint32_t _ptr_portname;
3506         TALLOC_CTX *_mem_save_portname_0;
3507         uint32_t _ptr_drivername;
3508         TALLOC_CTX *_mem_save_drivername_0;
3509         uint32_t _ptr_comment;
3510         TALLOC_CTX *_mem_save_comment_0;
3511         uint32_t _ptr_location;
3512         TALLOC_CTX *_mem_save_location_0;
3513         uint32_t _ptr_devmode;
3514         TALLOC_CTX *_mem_save_devmode_0;
3515         uint32_t _ptr_sepfile;
3516         TALLOC_CTX *_mem_save_sepfile_0;
3517         uint32_t _ptr_printprocessor;
3518         TALLOC_CTX *_mem_save_printprocessor_0;
3519         uint32_t _ptr_datatype;
3520         TALLOC_CTX *_mem_save_datatype_0;
3521         uint32_t _ptr_parameters;
3522         TALLOC_CTX *_mem_save_parameters_0;
3523         uint32_t _ptr_secdesc;
3524         TALLOC_CTX *_mem_save_secdesc_0;
3525         if (ndr_flags & NDR_SCALARS) {
3526                 NDR_CHECK(ndr_pull_align(ndr, 4));
3527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3528                 if (_ptr_servername) {
3529                         NDR_PULL_ALLOC(ndr, r->servername);
3530                 } else {
3531                         r->servername = NULL;
3532                 }
3533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3534                 if (_ptr_printername) {
3535                         NDR_PULL_ALLOC(ndr, r->printername);
3536                 } else {
3537                         r->printername = NULL;
3538                 }
3539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3540                 if (_ptr_sharename) {
3541                         NDR_PULL_ALLOC(ndr, r->sharename);
3542                 } else {
3543                         r->sharename = NULL;
3544                 }
3545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
3546                 if (_ptr_portname) {
3547                         NDR_PULL_ALLOC(ndr, r->portname);
3548                 } else {
3549                         r->portname = NULL;
3550                 }
3551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
3552                 if (_ptr_drivername) {
3553                         NDR_PULL_ALLOC(ndr, r->drivername);
3554                 } else {
3555                         r->drivername = NULL;
3556                 }
3557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3558                 if (_ptr_comment) {
3559                         NDR_PULL_ALLOC(ndr, r->comment);
3560                 } else {
3561                         r->comment = NULL;
3562                 }
3563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
3564                 if (_ptr_location) {
3565                         NDR_PULL_ALLOC(ndr, r->location);
3566                 } else {
3567                         r->location = NULL;
3568                 }
3569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3570                 if (_ptr_devmode) {
3571                         NDR_PULL_ALLOC(ndr, r->devmode);
3572                 } else {
3573                         r->devmode = NULL;
3574                 }
3575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
3576                 if (_ptr_sepfile) {
3577                         NDR_PULL_ALLOC(ndr, r->sepfile);
3578                 } else {
3579                         r->sepfile = NULL;
3580                 }
3581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
3582                 if (_ptr_printprocessor) {
3583                         NDR_PULL_ALLOC(ndr, r->printprocessor);
3584                 } else {
3585                         r->printprocessor = NULL;
3586                 }
3587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
3588                 if (_ptr_datatype) {
3589                         NDR_PULL_ALLOC(ndr, r->datatype);
3590                 } else {
3591                         r->datatype = NULL;
3592                 }
3593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3594                 if (_ptr_parameters) {
3595                         NDR_PULL_ALLOC(ndr, r->parameters);
3596                 } else {
3597                         r->parameters = NULL;
3598                 }
3599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3600                 if (_ptr_secdesc) {
3601                         NDR_PULL_ALLOC(ndr, r->secdesc);
3602                 } else {
3603                         r->secdesc = NULL;
3604                 }
3605                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
3609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
3610                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
3611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
3613         }
3614         if (ndr_flags & NDR_BUFFERS) {
3615                 if (r->servername) {
3616                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3617                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3620                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3621                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3622                         }
3623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3626                 }
3627                 if (r->printername) {
3628                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3629                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3632                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3633                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3634                         }
3635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3638                 }
3639                 if (r->sharename) {
3640                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3641                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
3642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
3643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
3644                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
3645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
3646                         }
3647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
3648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
3649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3650                 }
3651                 if (r->portname) {
3652                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3653                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
3654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
3655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
3656                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
3657                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
3658                         }
3659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
3660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
3661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
3662                 }
3663                 if (r->drivername) {
3664                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3665                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
3666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
3667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
3668                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
3669                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
3670                         }
3671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
3672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
3673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
3674                 }
3675                 if (r->comment) {
3676                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3677                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3680                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3681                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3682                         }
3683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3686                 }
3687                 if (r->location) {
3688                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
3689                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
3690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
3691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
3692                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
3693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
3694                         }
3695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
3696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
3697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
3698                 }
3699                 if (r->devmode) {
3700                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3701                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3702                         {
3703                                 struct ndr_pull *_ndr_devmode;
3704                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3705                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3706                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3707                         }
3708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3709                 }
3710                 if (r->sepfile) {
3711                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
3712                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
3713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
3714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
3715                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
3716                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
3717                         }
3718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
3719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
3720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
3721                 }
3722                 if (r->printprocessor) {
3723                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3724                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
3725                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
3726                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
3727                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
3728                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
3729                         }
3730                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
3731                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
3732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
3733                 }
3734                 if (r->datatype) {
3735                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
3736                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
3737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
3738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
3739                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
3740                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
3741                         }
3742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
3743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
3744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
3745                 }
3746                 if (r->parameters) {
3747                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3748                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3749                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
3750                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
3751                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
3752                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
3753                         }
3754                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
3755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
3756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3757                 }
3758                 if (r->secdesc) {
3759                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3760                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3761                         {
3762                                 struct ndr_pull *_ndr_secdesc;
3763                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3764                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3765                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3766                         }
3767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3768                 }
3769         }
3770         return NDR_ERR_SUCCESS;
3771 }
3772
3773 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
3774 {
3775         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
3776         ndr->depth++;
3777         ndr_print_ptr(ndr, "servername", r->servername);
3778         ndr->depth++;
3779         if (r->servername) {
3780                 ndr_print_string(ndr, "servername", r->servername);
3781         }
3782         ndr->depth--;
3783         ndr_print_ptr(ndr, "printername", r->printername);
3784         ndr->depth++;
3785         if (r->printername) {
3786                 ndr_print_string(ndr, "printername", r->printername);
3787         }
3788         ndr->depth--;
3789         ndr_print_ptr(ndr, "sharename", r->sharename);
3790         ndr->depth++;
3791         if (r->sharename) {
3792                 ndr_print_string(ndr, "sharename", r->sharename);
3793         }
3794         ndr->depth--;
3795         ndr_print_ptr(ndr, "portname", r->portname);
3796         ndr->depth++;
3797         if (r->portname) {
3798                 ndr_print_string(ndr, "portname", r->portname);
3799         }
3800         ndr->depth--;
3801         ndr_print_ptr(ndr, "drivername", r->drivername);
3802         ndr->depth++;
3803         if (r->drivername) {
3804                 ndr_print_string(ndr, "drivername", r->drivername);
3805         }
3806         ndr->depth--;
3807         ndr_print_ptr(ndr, "comment", r->comment);
3808         ndr->depth++;
3809         if (r->comment) {
3810                 ndr_print_string(ndr, "comment", r->comment);
3811         }
3812         ndr->depth--;
3813         ndr_print_ptr(ndr, "location", r->location);
3814         ndr->depth++;
3815         if (r->location) {
3816                 ndr_print_string(ndr, "location", r->location);
3817         }
3818         ndr->depth--;
3819         ndr_print_ptr(ndr, "devmode", r->devmode);
3820         ndr->depth++;
3821         if (r->devmode) {
3822                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3823         }
3824         ndr->depth--;
3825         ndr_print_ptr(ndr, "sepfile", r->sepfile);
3826         ndr->depth++;
3827         if (r->sepfile) {
3828                 ndr_print_string(ndr, "sepfile", r->sepfile);
3829         }
3830         ndr->depth--;
3831         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
3832         ndr->depth++;
3833         if (r->printprocessor) {
3834                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
3835         }
3836         ndr->depth--;
3837         ndr_print_ptr(ndr, "datatype", r->datatype);
3838         ndr->depth++;
3839         if (r->datatype) {
3840                 ndr_print_string(ndr, "datatype", r->datatype);
3841         }
3842         ndr->depth--;
3843         ndr_print_ptr(ndr, "parameters", r->parameters);
3844         ndr->depth++;
3845         if (r->parameters) {
3846                 ndr_print_string(ndr, "parameters", r->parameters);
3847         }
3848         ndr->depth--;
3849         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3850         ndr->depth++;
3851         if (r->secdesc) {
3852                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3853         }
3854         ndr->depth--;
3855         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
3856         ndr_print_uint32(ndr, "priority", r->priority);
3857         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
3858         ndr_print_uint32(ndr, "starttime", r->starttime);
3859         ndr_print_uint32(ndr, "untiltime", r->untiltime);
3860         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
3861         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3862         ndr_print_uint32(ndr, "averageppm", r->averageppm);
3863         ndr->depth--;
3864 }
3865
3866 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
3867 {
3868         if (ndr_flags & NDR_SCALARS) {
3869                 NDR_CHECK(ndr_push_align(ndr, 4));
3870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3871         }
3872         if (ndr_flags & NDR_BUFFERS) {
3873                 if (r->secdesc) {
3874                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3875                 }
3876         }
3877         return NDR_ERR_SUCCESS;
3878 }
3879
3880 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
3881 {
3882         uint32_t _ptr_secdesc;
3883         TALLOC_CTX *_mem_save_secdesc_0;
3884         if (ndr_flags & NDR_SCALARS) {
3885                 NDR_CHECK(ndr_pull_align(ndr, 4));
3886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3887                 if (_ptr_secdesc) {
3888                         NDR_PULL_ALLOC(ndr, r->secdesc);
3889                 } else {
3890                         r->secdesc = NULL;
3891                 }
3892         }
3893         if (ndr_flags & NDR_BUFFERS) {
3894                 if (r->secdesc) {
3895                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3896                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3897                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3899                 }
3900         }
3901         return NDR_ERR_SUCCESS;
3902 }
3903
3904 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
3905 {
3906         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
3907         ndr->depth++;
3908         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3909         ndr->depth++;
3910         if (r->secdesc) {
3911                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3912         }
3913         ndr->depth--;
3914         ndr->depth--;
3915 }
3916
3917 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
3918 {
3919         if (ndr_flags & NDR_SCALARS) {
3920                 NDR_CHECK(ndr_push_align(ndr, 4));
3921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3923                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3924         }
3925         if (ndr_flags & NDR_BUFFERS) {
3926                 if (r->printername) {
3927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3931                 }
3932                 if (r->servername) {
3933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3937                 }
3938         }
3939         return NDR_ERR_SUCCESS;
3940 }
3941
3942 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
3943 {
3944         uint32_t _ptr_printername;
3945         TALLOC_CTX *_mem_save_printername_0;
3946         uint32_t _ptr_servername;
3947         TALLOC_CTX *_mem_save_servername_0;
3948         if (ndr_flags & NDR_SCALARS) {
3949                 NDR_CHECK(ndr_pull_align(ndr, 4));
3950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3951                 if (_ptr_printername) {
3952                         NDR_PULL_ALLOC(ndr, r->printername);
3953                 } else {
3954                         r->printername = NULL;
3955                 }
3956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3957                 if (_ptr_servername) {
3958                         NDR_PULL_ALLOC(ndr, r->servername);
3959                 } else {
3960                         r->servername = NULL;
3961                 }
3962                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3963         }
3964         if (ndr_flags & NDR_BUFFERS) {
3965                 if (r->printername) {
3966                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3967                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3970                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3972                         }
3973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3976                 }
3977                 if (r->servername) {
3978                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3979                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3982                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3984                         }
3985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3988                 }
3989         }
3990         return NDR_ERR_SUCCESS;
3991 }
3992
3993 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
3994 {
3995         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
3996         ndr->depth++;
3997         ndr_print_ptr(ndr, "printername", r->printername);
3998         ndr->depth++;
3999         if (r->printername) {
4000                 ndr_print_string(ndr, "printername", r->printername);
4001         }
4002         ndr->depth--;
4003         ndr_print_ptr(ndr, "servername", r->servername);
4004         ndr->depth++;
4005         if (r->servername) {
4006                 ndr_print_string(ndr, "servername", r->servername);
4007         }
4008         ndr->depth--;
4009         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4010         ndr->depth--;
4011 }
4012
4013 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
4014 {
4015         if (ndr_flags & NDR_SCALARS) {
4016                 NDR_CHECK(ndr_push_align(ndr, 4));
4017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
4018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
4019                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
4020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
4021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
4022         }
4023         if (ndr_flags & NDR_BUFFERS) {
4024                 if (r->printername) {
4025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4029                 }
4030                 if (r->portname) {
4031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4035                 }
4036         }
4037         return NDR_ERR_SUCCESS;
4038 }
4039
4040 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
4041 {
4042         uint32_t _ptr_printername;
4043         TALLOC_CTX *_mem_save_printername_0;
4044         uint32_t _ptr_portname;
4045         TALLOC_CTX *_mem_save_portname_0;
4046         if (ndr_flags & NDR_SCALARS) {
4047                 NDR_CHECK(ndr_pull_align(ndr, 4));
4048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4049                 if (_ptr_printername) {
4050                         NDR_PULL_ALLOC(ndr, r->printername);
4051                 } else {
4052                         r->printername = NULL;
4053                 }
4054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
4055                 if (_ptr_portname) {
4056                         NDR_PULL_ALLOC(ndr, r->portname);
4057                 } else {
4058                         r->portname = NULL;
4059                 }
4060                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
4061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
4062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
4063         }
4064         if (ndr_flags & NDR_BUFFERS) {
4065                 if (r->printername) {
4066                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4067                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4070                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4071                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
4072                         }
4073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4076                 }
4077                 if (r->portname) {
4078                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
4079                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
4080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
4081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
4082                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
4083                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
4084                         }
4085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
4086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
4087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
4096         ndr->depth++;
4097         ndr_print_ptr(ndr, "printername", r->printername);
4098         ndr->depth++;
4099         if (r->printername) {
4100                 ndr_print_string(ndr, "printername", r->printername);
4101         }
4102         ndr->depth--;
4103         ndr_print_ptr(ndr, "portname", r->portname);
4104         ndr->depth++;
4105         if (r->portname) {
4106                 ndr_print_string(ndr, "portname", r->portname);
4107         }
4108         ndr->depth--;
4109         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4110         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
4111         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
4112         ndr->depth--;
4113 }
4114
4115 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
4116 {
4117         if (ndr_flags & NDR_SCALARS) {
4118                 NDR_CHECK(ndr_push_align(ndr, 4));
4119                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
4120         }
4121         if (ndr_flags & NDR_BUFFERS) {
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
4127 {
4128         if (ndr_flags & NDR_SCALARS) {
4129                 NDR_CHECK(ndr_pull_align(ndr, 4));
4130                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
4131         }
4132         if (ndr_flags & NDR_BUFFERS) {
4133         }
4134         return NDR_ERR_SUCCESS;
4135 }
4136
4137 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
4138 {
4139         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
4140         ndr->depth++;
4141         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
4142         ndr->depth--;
4143 }
4144
4145 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
4146 {
4147         if (ndr_flags & NDR_SCALARS) {
4148                 NDR_CHECK(ndr_push_align(ndr, 4));
4149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
4150                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
4151         }
4152         if (ndr_flags & NDR_BUFFERS) {
4153                 if (r->guid) {
4154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4158                 }
4159         }
4160         return NDR_ERR_SUCCESS;
4161 }
4162
4163 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
4164 {
4165         uint32_t _ptr_guid;
4166         TALLOC_CTX *_mem_save_guid_0;
4167         if (ndr_flags & NDR_SCALARS) {
4168                 NDR_CHECK(ndr_pull_align(ndr, 4));
4169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
4170                 if (_ptr_guid) {
4171                         NDR_PULL_ALLOC(ndr, r->guid);
4172                 } else {
4173                         r->guid = NULL;
4174                 }
4175                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
4176         }
4177         if (ndr_flags & NDR_BUFFERS) {
4178                 if (r->guid) {
4179                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4180                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
4181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
4182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
4183                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
4184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
4185                         }
4186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
4187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
4188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
4189                 }
4190         }
4191         return NDR_ERR_SUCCESS;
4192 }
4193
4194 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
4195 {
4196         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
4197         ndr->depth++;
4198         ndr_print_ptr(ndr, "guid", r->guid);
4199         ndr->depth++;
4200         if (r->guid) {
4201                 ndr_print_string(ndr, "guid", r->guid);
4202         }
4203         ndr->depth--;
4204         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
4205         ndr->depth--;
4206 }
4207
4208 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
4209 {
4210         if (ndr_flags & NDR_SCALARS) {
4211                 int level = ndr_push_get_switch_value(ndr, r);
4212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4213                 switch (level) {
4214                         case 0: {
4215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4216                         break; }
4217
4218                         case 1: {
4219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4220                         break; }
4221
4222                         case 2: {
4223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4224                         break; }
4225
4226                         case 3: {
4227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4228                         break; }
4229
4230                         case 4: {
4231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
4232                         break; }
4233
4234                         case 5: {
4235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
4236                         break; }
4237
4238                         case 6: {
4239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
4240                         break; }
4241
4242                         case 7: {
4243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
4244                         break; }
4245
4246                         case 8: {
4247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
4248                         break; }
4249
4250                         case 9: {
4251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
4252                         break; }
4253
4254                         default: {
4255                         break; }
4256
4257                 }
4258         }
4259         if (ndr_flags & NDR_BUFFERS) {
4260                 int level = ndr_push_get_switch_value(ndr, r);
4261                 switch (level) {
4262                         case 0:
4263                                 if (r->info0) {
4264                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4265                                 }
4266                         break;
4267
4268                         case 1:
4269                                 if (r->info1) {
4270                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4271                                 }
4272                         break;
4273
4274                         case 2:
4275                                 if (r->info2) {
4276                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4277                                 }
4278                         break;
4279
4280                         case 3:
4281                                 if (r->info3) {
4282                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4283                                 }
4284                         break;
4285
4286                         case 4:
4287                                 if (r->info4) {
4288                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4289                                 }
4290                         break;
4291
4292                         case 5:
4293                                 if (r->info5) {
4294                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4295                                 }
4296                         break;
4297
4298                         case 6:
4299                                 if (r->info6) {
4300                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4301                                 }
4302                         break;
4303
4304                         case 7:
4305                                 if (r->info7) {
4306                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4307                                 }
4308                         break;
4309
4310                         case 8:
4311                                 if (r->info8) {
4312                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4313                                 }
4314                         break;
4315
4316                         case 9:
4317                                 if (r->info9) {
4318                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4319                                 }
4320                         break;
4321
4322                         default:
4323                         break;
4324
4325                 }
4326         }
4327         return NDR_ERR_SUCCESS;
4328 }
4329
4330 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
4331 {
4332         int level;
4333         uint32_t _level;
4334         TALLOC_CTX *_mem_save_info0_0;
4335         TALLOC_CTX *_mem_save_info1_0;
4336         TALLOC_CTX *_mem_save_info2_0;
4337         TALLOC_CTX *_mem_save_info3_0;
4338         TALLOC_CTX *_mem_save_info4_0;
4339         TALLOC_CTX *_mem_save_info5_0;
4340         TALLOC_CTX *_mem_save_info6_0;
4341         TALLOC_CTX *_mem_save_info7_0;
4342         TALLOC_CTX *_mem_save_info8_0;
4343         TALLOC_CTX *_mem_save_info9_0;
4344         level = ndr_pull_get_switch_value(ndr, r);
4345         if (ndr_flags & NDR_SCALARS) {
4346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4347                 if (_level != level) {
4348                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4349                 }
4350                 switch (level) {
4351                         case 0: {
4352                                 uint32_t _ptr_info0;
4353                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4354                                 if (_ptr_info0) {
4355                                         NDR_PULL_ALLOC(ndr, r->info0);
4356                                 } else {
4357                                         r->info0 = NULL;
4358                                 }
4359                         break; }
4360
4361                         case 1: {
4362                                 uint32_t _ptr_info1;
4363                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4364                                 if (_ptr_info1) {
4365                                         NDR_PULL_ALLOC(ndr, r->info1);
4366                                 } else {
4367                                         r->info1 = NULL;
4368                                 }
4369                         break; }
4370
4371                         case 2: {
4372                                 uint32_t _ptr_info2;
4373                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4374                                 if (_ptr_info2) {
4375                                         NDR_PULL_ALLOC(ndr, r->info2);
4376                                 } else {
4377                                         r->info2 = NULL;
4378                                 }
4379                         break; }
4380
4381                         case 3: {
4382                                 uint32_t _ptr_info3;
4383                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4384                                 if (_ptr_info3) {
4385                                         NDR_PULL_ALLOC(ndr, r->info3);
4386                                 } else {
4387                                         r->info3 = NULL;
4388                                 }
4389                         break; }
4390
4391                         case 4: {
4392                                 uint32_t _ptr_info4;
4393                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
4394                                 if (_ptr_info4) {
4395                                         NDR_PULL_ALLOC(ndr, r->info4);
4396                                 } else {
4397                                         r->info4 = NULL;
4398                                 }
4399                         break; }
4400
4401                         case 5: {
4402                                 uint32_t _ptr_info5;
4403                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
4404                                 if (_ptr_info5) {
4405                                         NDR_PULL_ALLOC(ndr, r->info5);
4406                                 } else {
4407                                         r->info5 = NULL;
4408                                 }
4409                         break; }
4410
4411                         case 6: {
4412                                 uint32_t _ptr_info6;
4413                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
4414                                 if (_ptr_info6) {
4415                                         NDR_PULL_ALLOC(ndr, r->info6);
4416                                 } else {
4417                                         r->info6 = NULL;
4418                                 }
4419                         break; }
4420
4421                         case 7: {
4422                                 uint32_t _ptr_info7;
4423                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
4424                                 if (_ptr_info7) {
4425                                         NDR_PULL_ALLOC(ndr, r->info7);
4426                                 } else {
4427                                         r->info7 = NULL;
4428                                 }
4429                         break; }
4430
4431                         case 8: {
4432                                 uint32_t _ptr_info8;
4433                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
4434                                 if (_ptr_info8) {
4435                                         NDR_PULL_ALLOC(ndr, r->info8);
4436                                 } else {
4437                                         r->info8 = NULL;
4438                                 }
4439                         break; }
4440
4441                         case 9: {
4442                                 uint32_t _ptr_info9;
4443                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
4444                                 if (_ptr_info9) {
4445                                         NDR_PULL_ALLOC(ndr, r->info9);
4446                                 } else {
4447                                         r->info9 = NULL;
4448                                 }
4449                         break; }
4450
4451                         default: {
4452                         break; }
4453
4454                 }
4455         }
4456         if (ndr_flags & NDR_BUFFERS) {
4457                 switch (level) {
4458                         case 0:
4459                                 if (r->info0) {
4460                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4461                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4462                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4463                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4464                                 }
4465                         break;
4466
4467                         case 1:
4468                                 if (r->info1) {
4469                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4470                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4471                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4472                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4473                                 }
4474                         break;
4475
4476                         case 2:
4477                                 if (r->info2) {
4478                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4479                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4480                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4481                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4482                                 }
4483                         break;
4484
4485                         case 3:
4486                                 if (r->info3) {
4487                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4488                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4489                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4490                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4491                                 }
4492                         break;
4493
4494                         case 4:
4495                                 if (r->info4) {
4496                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
4497                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
4498                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4499                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
4500                                 }
4501                         break;
4502
4503                         case 5:
4504                                 if (r->info5) {
4505                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
4506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
4507                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
4509                                 }
4510                         break;
4511
4512                         case 6:
4513                                 if (r->info6) {
4514                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
4515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
4516                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
4518                                 }
4519                         break;
4520
4521                         case 7:
4522                                 if (r->info7) {
4523                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
4524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
4525                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
4527                                 }
4528                         break;
4529
4530                         case 8:
4531                                 if (r->info8) {
4532                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
4534                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
4536                                 }
4537                         break;
4538
4539                         case 9:
4540                                 if (r->info9) {
4541                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
4542                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
4543                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
4545                                 }
4546                         break;
4547
4548                         default:
4549                         break;
4550
4551                 }
4552         }
4553         return NDR_ERR_SUCCESS;
4554 }
4555
4556 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
4557 {
4558         int level;
4559         level = ndr_print_get_switch_value(ndr, r);
4560         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
4561         switch (level) {
4562                 case 0:
4563                         ndr_print_ptr(ndr, "info0", r->info0);
4564                         ndr->depth++;
4565                         if (r->info0) {
4566                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
4567                         }
4568                         ndr->depth--;
4569                 break;
4570
4571                 case 1:
4572                         ndr_print_ptr(ndr, "info1", r->info1);
4573                         ndr->depth++;
4574                         if (r->info1) {
4575                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
4576                         }
4577                         ndr->depth--;
4578                 break;
4579
4580                 case 2:
4581                         ndr_print_ptr(ndr, "info2", r->info2);
4582                         ndr->depth++;
4583                         if (r->info2) {
4584                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
4585                         }
4586                         ndr->depth--;
4587                 break;
4588
4589                 case 3:
4590                         ndr_print_ptr(ndr, "info3", r->info3);
4591                         ndr->depth++;
4592                         if (r->info3) {
4593                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
4594                         }
4595                         ndr->depth--;
4596                 break;
4597
4598                 case 4:
4599                         ndr_print_ptr(ndr, "info4", r->info4);
4600                         ndr->depth++;
4601                         if (r->info4) {
4602                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
4603                         }
4604                         ndr->depth--;
4605                 break;
4606
4607                 case 5:
4608                         ndr_print_ptr(ndr, "info5", r->info5);
4609                         ndr->depth++;
4610                         if (r->info5) {
4611                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
4612                         }
4613                         ndr->depth--;
4614                 break;
4615
4616                 case 6:
4617                         ndr_print_ptr(ndr, "info6", r->info6);
4618                         ndr->depth++;
4619                         if (r->info6) {
4620                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
4621                         }
4622                         ndr->depth--;
4623                 break;
4624
4625                 case 7:
4626                         ndr_print_ptr(ndr, "info7", r->info7);
4627                         ndr->depth++;
4628                         if (r->info7) {
4629                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
4630                         }
4631                         ndr->depth--;
4632                 break;
4633
4634                 case 8:
4635                         ndr_print_ptr(ndr, "info8", r->info8);
4636                         ndr->depth++;
4637                         if (r->info8) {
4638                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
4639                         }
4640                         ndr->depth--;
4641                 break;
4642
4643                 case 9:
4644                         ndr_print_ptr(ndr, "info9", r->info9);
4645                         ndr->depth++;
4646                         if (r->info9) {
4647                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
4648                         }
4649                         ndr->depth--;
4650                 break;
4651
4652                 default:
4653                 break;
4654
4655         }
4656 }
4657
4658 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
4659 {
4660         if (ndr_flags & NDR_SCALARS) {
4661                 NDR_CHECK(ndr_push_align(ndr, 4));
4662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
4664                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4665         }
4666         if (ndr_flags & NDR_BUFFERS) {
4667                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4668         }
4669         return NDR_ERR_SUCCESS;
4670 }
4671
4672 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
4673 {
4674         if (ndr_flags & NDR_SCALARS) {
4675                 NDR_CHECK(ndr_pull_align(ndr, 4));
4676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4677                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
4678                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4679         }
4680         if (ndr_flags & NDR_BUFFERS) {
4681                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4682         }
4683         return NDR_ERR_SUCCESS;
4684 }
4685
4686 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
4687 {
4688         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
4689         ndr->depth++;
4690         ndr_print_uint32(ndr, "level", r->level);
4691         ndr_print_set_switch_value(ndr, &r->info, r->level);
4692         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
4693         ndr->depth--;
4694 }
4695
4696 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
4697 {
4698         if (ndr_flags & NDR_SCALARS) {
4699                 NDR_CHECK(ndr_push_align(ndr, 4));
4700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
4701                 {
4702                         uint32_t _flags_save_string_array = ndr->flags;
4703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4704                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
4705                         ndr->flags = _flags_save_string_array;
4706                 }
4707         }
4708         if (ndr_flags & NDR_BUFFERS) {
4709         }
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
4714 {
4715         if (ndr_flags & NDR_SCALARS) {
4716                 NDR_CHECK(ndr_pull_align(ndr, 4));
4717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
4718                 {
4719                         uint32_t _flags_save_string_array = ndr->flags;
4720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4721                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
4722                         ndr->flags = _flags_save_string_array;
4723                 }
4724         }
4725         if (ndr_flags & NDR_BUFFERS) {
4726         }
4727         return NDR_ERR_SUCCESS;
4728 }
4729
4730 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
4731 {
4732         ndr_print_struct(ndr, name, "spoolss_StringArray");
4733         ndr->depth++;
4734         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
4735         ndr_print_string_array(ndr, "string", r->string);
4736         ndr->depth--;
4737 }
4738
4739 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
4740 {
4741         if (ndr_flags & NDR_SCALARS) {
4742                 NDR_CHECK(ndr_push_align(ndr, 4));
4743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4744         }
4745         if (ndr_flags & NDR_BUFFERS) {
4746                 if (r->driver_name) {
4747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4751                 }
4752         }
4753         return NDR_ERR_SUCCESS;
4754 }
4755
4756 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
4757 {
4758         uint32_t _ptr_driver_name;
4759         TALLOC_CTX *_mem_save_driver_name_0;
4760         if (ndr_flags & NDR_SCALARS) {
4761                 NDR_CHECK(ndr_pull_align(ndr, 4));
4762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4763                 if (_ptr_driver_name) {
4764                         NDR_PULL_ALLOC(ndr, r->driver_name);
4765                 } else {
4766                         r->driver_name = NULL;
4767                 }
4768         }
4769         if (ndr_flags & NDR_BUFFERS) {
4770                 if (r->driver_name) {
4771                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4772                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4775                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4776                                 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));
4777                         }
4778                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4779                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4781                 }
4782         }
4783         return NDR_ERR_SUCCESS;
4784 }
4785
4786 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
4787 {
4788         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
4789         ndr->depth++;
4790         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4791         ndr->depth++;
4792         if (r->driver_name) {
4793                 ndr_print_string(ndr, "driver_name", r->driver_name);
4794         }
4795         ndr->depth--;
4796         ndr->depth--;
4797 }
4798
4799 static enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
4800 {
4801         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4802         return NDR_ERR_SUCCESS;
4803 }
4804
4805 static enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
4806 {
4807         uint32_t v;
4808         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4809         *r = v;
4810         return NDR_ERR_SUCCESS;
4811 }
4812
4813 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
4814 {
4815         const char *val = NULL;
4816
4817         switch (r) {
4818                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
4819                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
4820                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
4821                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
4822         }
4823         ndr_print_enum(ndr, name, "ENUM", val, r);
4824 }
4825
4826 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
4827 {
4828         if (ndr_flags & NDR_SCALARS) {
4829                 NDR_CHECK(ndr_push_align(ndr, 4));
4830                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4831                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
4833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
4834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
4835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
4836         }
4837         if (ndr_flags & NDR_BUFFERS) {
4838                 if (r->driver_name) {
4839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4843                 }
4844                 if (r->architecture) {
4845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4848                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4849                 }
4850                 if (r->driver_path) {
4851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4854                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4855                 }
4856                 if (r->data_file) {
4857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4861                 }
4862                 if (r->config_file) {
4863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4867                 }
4868         }
4869         return NDR_ERR_SUCCESS;
4870 }
4871
4872 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
4873 {
4874         uint32_t _ptr_driver_name;
4875         TALLOC_CTX *_mem_save_driver_name_0;
4876         uint32_t _ptr_architecture;
4877         TALLOC_CTX *_mem_save_architecture_0;
4878         uint32_t _ptr_driver_path;
4879         TALLOC_CTX *_mem_save_driver_path_0;
4880         uint32_t _ptr_data_file;
4881         TALLOC_CTX *_mem_save_data_file_0;
4882         uint32_t _ptr_config_file;
4883         TALLOC_CTX *_mem_save_config_file_0;
4884         if (ndr_flags & NDR_SCALARS) {
4885                 NDR_CHECK(ndr_pull_align(ndr, 4));
4886                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4887                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4888                 if (_ptr_driver_name) {
4889                         NDR_PULL_ALLOC(ndr, r->driver_name);
4890                 } else {
4891                         r->driver_name = NULL;
4892                 }
4893                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4894                 if (_ptr_architecture) {
4895                         NDR_PULL_ALLOC(ndr, r->architecture);
4896                 } else {
4897                         r->architecture = NULL;
4898                 }
4899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4900                 if (_ptr_driver_path) {
4901                         NDR_PULL_ALLOC(ndr, r->driver_path);
4902                 } else {
4903                         r->driver_path = NULL;
4904                 }
4905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4906                 if (_ptr_data_file) {
4907                         NDR_PULL_ALLOC(ndr, r->data_file);
4908                 } else {
4909                         r->data_file = NULL;
4910                 }
4911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4912                 if (_ptr_config_file) {
4913                         NDR_PULL_ALLOC(ndr, r->config_file);
4914                 } else {
4915                         r->config_file = NULL;
4916                 }
4917         }
4918         if (ndr_flags & NDR_BUFFERS) {
4919                 if (r->driver_name) {
4920                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4921                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4922                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4923                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4924                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4925                                 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));
4926                         }
4927                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4930                 }
4931                 if (r->architecture) {
4932                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4933                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4934                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
4935                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
4936                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
4937                                 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));
4938                         }
4939                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
4940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
4941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4942                 }
4943                 if (r->driver_path) {
4944                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4945                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
4947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
4948                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
4949                                 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));
4950                         }
4951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
4952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
4953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4954                 }
4955                 if (r->data_file) {
4956                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4957                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
4959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
4960                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
4961                                 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));
4962                         }
4963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
4964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
4965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4966                 }
4967                 if (r->config_file) {
4968                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4969                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
4971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
4972                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
4973                                 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));
4974                         }
4975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
4976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
4977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4978                 }
4979         }
4980         return NDR_ERR_SUCCESS;
4981 }
4982
4983 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
4984 {
4985         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
4986         ndr->depth++;
4987         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4988         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4989         ndr->depth++;
4990         if (r->driver_name) {
4991                 ndr_print_string(ndr, "driver_name", r->driver_name);
4992         }
4993         ndr->depth--;
4994         ndr_print_ptr(ndr, "architecture", r->architecture);
4995         ndr->depth++;
4996         if (r->architecture) {
4997                 ndr_print_string(ndr, "architecture", r->architecture);
4998         }
4999         ndr->depth--;
5000         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5001         ndr->depth++;
5002         if (r->driver_path) {
5003                 ndr_print_string(ndr, "driver_path", r->driver_path);
5004         }
5005         ndr->depth--;
5006         ndr_print_ptr(ndr, "data_file", r->data_file);
5007         ndr->depth++;
5008         if (r->data_file) {
5009                 ndr_print_string(ndr, "data_file", r->data_file);
5010         }
5011         ndr->depth--;
5012         ndr_print_ptr(ndr, "config_file", r->config_file);
5013         ndr->depth++;
5014         if (r->config_file) {
5015                 ndr_print_string(ndr, "config_file", r->config_file);
5016         }
5017         ndr->depth--;
5018         ndr->depth--;
5019 }
5020
5021 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
5022 {
5023         if (ndr_flags & NDR_SCALARS) {
5024                 NDR_CHECK(ndr_push_align(ndr, 4));
5025                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5026                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5036         }
5037         if (ndr_flags & NDR_BUFFERS) {
5038                 if (r->driver_name) {
5039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5042                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5043                 }
5044                 if (r->architecture) {
5045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5048                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5049                 }
5050                 if (r->driver_path) {
5051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5054                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5055                 }
5056                 if (r->data_file) {
5057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5060                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5061                 }
5062                 if (r->config_file) {
5063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5066                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5067                 }
5068                 if (r->help_file) {
5069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5072                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5073                 }
5074                 if (r->monitor_name) {
5075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5078                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5079                 }
5080                 if (r->default_datatype) {
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5085                 }
5086                 if (r->dependent_files) {
5087                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5088                 }
5089         }
5090         return NDR_ERR_SUCCESS;
5091 }
5092
5093 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
5094 {
5095         uint32_t _ptr_driver_name;
5096         TALLOC_CTX *_mem_save_driver_name_0;
5097         uint32_t _ptr_architecture;
5098         TALLOC_CTX *_mem_save_architecture_0;
5099         uint32_t _ptr_driver_path;
5100         TALLOC_CTX *_mem_save_driver_path_0;
5101         uint32_t _ptr_data_file;
5102         TALLOC_CTX *_mem_save_data_file_0;
5103         uint32_t _ptr_config_file;
5104         TALLOC_CTX *_mem_save_config_file_0;
5105         uint32_t _ptr_help_file;
5106         TALLOC_CTX *_mem_save_help_file_0;
5107         uint32_t _ptr_monitor_name;
5108         TALLOC_CTX *_mem_save_monitor_name_0;
5109         uint32_t _ptr_default_datatype;
5110         TALLOC_CTX *_mem_save_default_datatype_0;
5111         uint32_t _ptr_dependent_files;
5112         TALLOC_CTX *_mem_save_dependent_files_0;
5113         if (ndr_flags & NDR_SCALARS) {
5114                 NDR_CHECK(ndr_pull_align(ndr, 4));
5115                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5117                 if (_ptr_driver_name) {
5118                         NDR_PULL_ALLOC(ndr, r->driver_name);
5119                 } else {
5120                         r->driver_name = NULL;
5121                 }
5122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5123                 if (_ptr_architecture) {
5124                         NDR_PULL_ALLOC(ndr, r->architecture);
5125                 } else {
5126                         r->architecture = NULL;
5127                 }
5128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5129                 if (_ptr_driver_path) {
5130                         NDR_PULL_ALLOC(ndr, r->driver_path);
5131                 } else {
5132                         r->driver_path = NULL;
5133                 }
5134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5135                 if (_ptr_data_file) {
5136                         NDR_PULL_ALLOC(ndr, r->data_file);
5137                 } else {
5138                         r->data_file = NULL;
5139                 }
5140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5141                 if (_ptr_config_file) {
5142                         NDR_PULL_ALLOC(ndr, r->config_file);
5143                 } else {
5144                         r->config_file = NULL;
5145                 }
5146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5147                 if (_ptr_help_file) {
5148                         NDR_PULL_ALLOC(ndr, r->help_file);
5149                 } else {
5150                         r->help_file = NULL;
5151                 }
5152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5153                 if (_ptr_monitor_name) {
5154                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5155                 } else {
5156                         r->monitor_name = NULL;
5157                 }
5158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5159                 if (_ptr_default_datatype) {
5160                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5161                 } else {
5162                         r->default_datatype = NULL;
5163                 }
5164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5166                 if (_ptr_dependent_files) {
5167                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5168                 } else {
5169                         r->dependent_files = NULL;
5170                 }
5171         }
5172         if (ndr_flags & NDR_BUFFERS) {
5173                 if (r->driver_name) {
5174                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5175                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5178                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5179                                 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));
5180                         }
5181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5184                 }
5185                 if (r->architecture) {
5186                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5187                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5188                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5189                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5190                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5191                                 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));
5192                         }
5193                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5194                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5196                 }
5197                 if (r->driver_path) {
5198                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5199                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5201                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5202                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5203                                 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));
5204                         }
5205                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5206                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5208                 }
5209                 if (r->data_file) {
5210                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5211                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5212                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5213                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5214                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5215                                 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));
5216                         }
5217                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5218                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5220                 }
5221                 if (r->config_file) {
5222                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5223                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5224                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5225                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5226                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5227                                 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));
5228                         }
5229                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5230                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5232                 }
5233                 if (r->help_file) {
5234                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5235                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5236                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5237                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5238                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5239                                 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));
5240                         }
5241                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5242                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5244                 }
5245                 if (r->monitor_name) {
5246                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5247                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5249                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5250                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5251                                 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));
5252                         }
5253                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5254                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5256                 }
5257                 if (r->default_datatype) {
5258                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5259                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5260                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5261                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5262                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5263                                 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));
5264                         }
5265                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5266                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5268                 }
5269                 if (r->dependent_files) {
5270                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5271                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5272                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5274                 }
5275         }
5276         return NDR_ERR_SUCCESS;
5277 }
5278
5279 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
5280 {
5281         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
5282         ndr->depth++;
5283         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5284         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5285         ndr->depth++;
5286         if (r->driver_name) {
5287                 ndr_print_string(ndr, "driver_name", r->driver_name);
5288         }
5289         ndr->depth--;
5290         ndr_print_ptr(ndr, "architecture", r->architecture);
5291         ndr->depth++;
5292         if (r->architecture) {
5293                 ndr_print_string(ndr, "architecture", r->architecture);
5294         }
5295         ndr->depth--;
5296         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5297         ndr->depth++;
5298         if (r->driver_path) {
5299                 ndr_print_string(ndr, "driver_path", r->driver_path);
5300         }
5301         ndr->depth--;
5302         ndr_print_ptr(ndr, "data_file", r->data_file);
5303         ndr->depth++;
5304         if (r->data_file) {
5305                 ndr_print_string(ndr, "data_file", r->data_file);
5306         }
5307         ndr->depth--;
5308         ndr_print_ptr(ndr, "config_file", r->config_file);
5309         ndr->depth++;
5310         if (r->config_file) {
5311                 ndr_print_string(ndr, "config_file", r->config_file);
5312         }
5313         ndr->depth--;
5314         ndr_print_ptr(ndr, "help_file", r->help_file);
5315         ndr->depth++;
5316         if (r->help_file) {
5317                 ndr_print_string(ndr, "help_file", r->help_file);
5318         }
5319         ndr->depth--;
5320         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5321         ndr->depth++;
5322         if (r->monitor_name) {
5323                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5324         }
5325         ndr->depth--;
5326         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5327         ndr->depth++;
5328         if (r->default_datatype) {
5329                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5330         }
5331         ndr->depth--;
5332         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);
5333         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5334         ndr->depth++;
5335         if (r->dependent_files) {
5336                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5337         }
5338         ndr->depth--;
5339         ndr->depth--;
5340 }
5341
5342 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
5343 {
5344         if (ndr_flags & NDR_SCALARS) {
5345                 NDR_CHECK(ndr_push_align(ndr, 4));
5346                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5359         }
5360         if (ndr_flags & NDR_BUFFERS) {
5361                 if (r->driver_name) {
5362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5365                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5366                 }
5367                 if (r->architecture) {
5368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5371                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5372                 }
5373                 if (r->driver_path) {
5374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5378                 }
5379                 if (r->data_file) {
5380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5383                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5384                 }
5385                 if (r->config_file) {
5386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5390                 }
5391                 if (r->help_file) {
5392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5394                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5396                 }
5397                 if (r->monitor_name) {
5398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5402                 }
5403                 if (r->default_datatype) {
5404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5408                 }
5409                 if (r->dependent_files) {
5410                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5411                 }
5412                 if (r->previous_names) {
5413                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5414                 }
5415         }
5416         return NDR_ERR_SUCCESS;
5417 }
5418
5419 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
5420 {
5421         uint32_t _ptr_driver_name;
5422         TALLOC_CTX *_mem_save_driver_name_0;
5423         uint32_t _ptr_architecture;
5424         TALLOC_CTX *_mem_save_architecture_0;
5425         uint32_t _ptr_driver_path;
5426         TALLOC_CTX *_mem_save_driver_path_0;
5427         uint32_t _ptr_data_file;
5428         TALLOC_CTX *_mem_save_data_file_0;
5429         uint32_t _ptr_config_file;
5430         TALLOC_CTX *_mem_save_config_file_0;
5431         uint32_t _ptr_help_file;
5432         TALLOC_CTX *_mem_save_help_file_0;
5433         uint32_t _ptr_monitor_name;
5434         TALLOC_CTX *_mem_save_monitor_name_0;
5435         uint32_t _ptr_default_datatype;
5436         TALLOC_CTX *_mem_save_default_datatype_0;
5437         uint32_t _ptr_dependent_files;
5438         TALLOC_CTX *_mem_save_dependent_files_0;
5439         uint32_t _ptr_previous_names;
5440         TALLOC_CTX *_mem_save_previous_names_0;
5441         if (ndr_flags & NDR_SCALARS) {
5442                 NDR_CHECK(ndr_pull_align(ndr, 4));
5443                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5445                 if (_ptr_driver_name) {
5446                         NDR_PULL_ALLOC(ndr, r->driver_name);
5447                 } else {
5448                         r->driver_name = NULL;
5449                 }
5450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5451                 if (_ptr_architecture) {
5452                         NDR_PULL_ALLOC(ndr, r->architecture);
5453                 } else {
5454                         r->architecture = NULL;
5455                 }
5456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5457                 if (_ptr_driver_path) {
5458                         NDR_PULL_ALLOC(ndr, r->driver_path);
5459                 } else {
5460                         r->driver_path = NULL;
5461                 }
5462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5463                 if (_ptr_data_file) {
5464                         NDR_PULL_ALLOC(ndr, r->data_file);
5465                 } else {
5466                         r->data_file = NULL;
5467                 }
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5469                 if (_ptr_config_file) {
5470                         NDR_PULL_ALLOC(ndr, r->config_file);
5471                 } else {
5472                         r->config_file = NULL;
5473                 }
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5475                 if (_ptr_help_file) {
5476                         NDR_PULL_ALLOC(ndr, r->help_file);
5477                 } else {
5478                         r->help_file = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5481                 if (_ptr_monitor_name) {
5482                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5483                 } else {
5484                         r->monitor_name = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5487                 if (_ptr_default_datatype) {
5488                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5489                 } else {
5490                         r->default_datatype = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5494                 if (_ptr_dependent_files) {
5495                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5496                 } else {
5497                         r->dependent_files = NULL;
5498                 }
5499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5501                 if (_ptr_previous_names) {
5502                         NDR_PULL_ALLOC(ndr, r->previous_names);
5503                 } else {
5504                         r->previous_names = NULL;
5505                 }
5506         }
5507         if (ndr_flags & NDR_BUFFERS) {
5508                 if (r->driver_name) {
5509                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5510                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5511                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5512                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5513                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5514                                 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));
5515                         }
5516                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5517                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5519                 }
5520                 if (r->architecture) {
5521                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5522                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5523                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5524                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5525                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5526                                 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));
5527                         }
5528                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5531                 }
5532                 if (r->driver_path) {
5533                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5534                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5535                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5536                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5537                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5538                                 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));
5539                         }
5540                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5541                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5543                 }
5544                 if (r->data_file) {
5545                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5546                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5547                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5548                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5549                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5550                                 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));
5551                         }
5552                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5553                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5555                 }
5556                 if (r->config_file) {
5557                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5558                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5560                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5561                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5562                                 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));
5563                         }
5564                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5565                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5567                 }
5568                 if (r->help_file) {
5569                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5570                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5573                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5574                                 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));
5575                         }
5576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5579                 }
5580                 if (r->monitor_name) {
5581                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5582                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5585                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5586                                 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));
5587                         }
5588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5591                 }
5592                 if (r->default_datatype) {
5593                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5594                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5597                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5598                                 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));
5599                         }
5600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5603                 }
5604                 if (r->dependent_files) {
5605                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5606                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5607                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5609                 }
5610                 if (r->previous_names) {
5611                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5612                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
5613                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
5615                 }
5616         }
5617         return NDR_ERR_SUCCESS;
5618 }
5619
5620 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
5621 {
5622         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
5623         ndr->depth++;
5624         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5625         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5626         ndr->depth++;
5627         if (r->driver_name) {
5628                 ndr_print_string(ndr, "driver_name", r->driver_name);
5629         }
5630         ndr->depth--;
5631         ndr_print_ptr(ndr, "architecture", r->architecture);
5632         ndr->depth++;
5633         if (r->architecture) {
5634                 ndr_print_string(ndr, "architecture", r->architecture);
5635         }
5636         ndr->depth--;
5637         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5638         ndr->depth++;
5639         if (r->driver_path) {
5640                 ndr_print_string(ndr, "driver_path", r->driver_path);
5641         }
5642         ndr->depth--;
5643         ndr_print_ptr(ndr, "data_file", r->data_file);
5644         ndr->depth++;
5645         if (r->data_file) {
5646                 ndr_print_string(ndr, "data_file", r->data_file);
5647         }
5648         ndr->depth--;
5649         ndr_print_ptr(ndr, "config_file", r->config_file);
5650         ndr->depth++;
5651         if (r->config_file) {
5652                 ndr_print_string(ndr, "config_file", r->config_file);
5653         }
5654         ndr->depth--;
5655         ndr_print_ptr(ndr, "help_file", r->help_file);
5656         ndr->depth++;
5657         if (r->help_file) {
5658                 ndr_print_string(ndr, "help_file", r->help_file);
5659         }
5660         ndr->depth--;
5661         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5662         ndr->depth++;
5663         if (r->monitor_name) {
5664                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5665         }
5666         ndr->depth--;
5667         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5668         ndr->depth++;
5669         if (r->default_datatype) {
5670                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5671         }
5672         ndr->depth--;
5673         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);
5674         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5675         ndr->depth++;
5676         if (r->dependent_files) {
5677                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5678         }
5679         ndr->depth--;
5680         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);
5681         ndr_print_ptr(ndr, "previous_names", r->previous_names);
5682         ndr->depth++;
5683         if (r->previous_names) {
5684                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
5685         }
5686         ndr->depth--;
5687         ndr->depth--;
5688 }
5689
5690 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
5691 {
5692         if (ndr_flags & NDR_SCALARS) {
5693                 NDR_CHECK(ndr_push_align(ndr, 8));
5694                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5707                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
5708                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
5709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
5710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
5711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
5712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
5713         }
5714         if (ndr_flags & NDR_BUFFERS) {
5715                 if (r->driver_name) {
5716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5720                 }
5721                 if (r->architecture) {
5722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5726                 }
5727                 if (r->driver_path) {
5728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5732                 }
5733                 if (r->data_file) {
5734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5737                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5738                 }
5739                 if (r->config_file) {
5740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5744                 }
5745                 if (r->help_file) {
5746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5749                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5750                 }
5751                 if (r->monitor_name) {
5752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5756                 }
5757                 if (r->default_datatype) {
5758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5762                 }
5763                 if (r->dependent_files) {
5764                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5765                 }
5766                 if (r->previous_names) {
5767                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5768                 }
5769                 if (r->manufacturer_name) {
5770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5774                 }
5775                 if (r->manufacturer_url) {
5776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5778                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5780                 }
5781                 if (r->hardware_id) {
5782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5784                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5786                 }
5787                 if (r->provider) {
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5792                 }
5793         }
5794         return NDR_ERR_SUCCESS;
5795 }
5796
5797 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
5798 {
5799         uint32_t _ptr_driver_name;
5800         TALLOC_CTX *_mem_save_driver_name_0;
5801         uint32_t _ptr_architecture;
5802         TALLOC_CTX *_mem_save_architecture_0;
5803         uint32_t _ptr_driver_path;
5804         TALLOC_CTX *_mem_save_driver_path_0;
5805         uint32_t _ptr_data_file;
5806         TALLOC_CTX *_mem_save_data_file_0;
5807         uint32_t _ptr_config_file;
5808         TALLOC_CTX *_mem_save_config_file_0;
5809         uint32_t _ptr_help_file;
5810         TALLOC_CTX *_mem_save_help_file_0;
5811         uint32_t _ptr_monitor_name;
5812         TALLOC_CTX *_mem_save_monitor_name_0;
5813         uint32_t _ptr_default_datatype;
5814         TALLOC_CTX *_mem_save_default_datatype_0;
5815         uint32_t _ptr_dependent_files;
5816         TALLOC_CTX *_mem_save_dependent_files_0;
5817         uint32_t _ptr_previous_names;
5818         TALLOC_CTX *_mem_save_previous_names_0;
5819         uint32_t _ptr_manufacturer_name;
5820         TALLOC_CTX *_mem_save_manufacturer_name_0;
5821         uint32_t _ptr_manufacturer_url;
5822         TALLOC_CTX *_mem_save_manufacturer_url_0;
5823         uint32_t _ptr_hardware_id;
5824         TALLOC_CTX *_mem_save_hardware_id_0;
5825         uint32_t _ptr_provider;
5826         TALLOC_CTX *_mem_save_provider_0;
5827         if (ndr_flags & NDR_SCALARS) {
5828                 NDR_CHECK(ndr_pull_align(ndr, 8));
5829                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5831                 if (_ptr_driver_name) {
5832                         NDR_PULL_ALLOC(ndr, r->driver_name);
5833                 } else {
5834                         r->driver_name = NULL;
5835                 }
5836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5837                 if (_ptr_architecture) {
5838                         NDR_PULL_ALLOC(ndr, r->architecture);
5839                 } else {
5840                         r->architecture = NULL;
5841                 }
5842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5843                 if (_ptr_driver_path) {
5844                         NDR_PULL_ALLOC(ndr, r->driver_path);
5845                 } else {
5846                         r->driver_path = NULL;
5847                 }
5848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5849                 if (_ptr_data_file) {
5850                         NDR_PULL_ALLOC(ndr, r->data_file);
5851                 } else {
5852                         r->data_file = NULL;
5853                 }
5854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5855                 if (_ptr_config_file) {
5856                         NDR_PULL_ALLOC(ndr, r->config_file);
5857                 } else {
5858                         r->config_file = NULL;
5859                 }
5860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5861                 if (_ptr_help_file) {
5862                         NDR_PULL_ALLOC(ndr, r->help_file);
5863                 } else {
5864                         r->help_file = NULL;
5865                 }
5866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5867                 if (_ptr_monitor_name) {
5868                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5869                 } else {
5870                         r->monitor_name = NULL;
5871                 }
5872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5873                 if (_ptr_default_datatype) {
5874                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5875                 } else {
5876                         r->default_datatype = NULL;
5877                 }
5878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5880                 if (_ptr_dependent_files) {
5881                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5882                 } else {
5883                         r->dependent_files = NULL;
5884                 }
5885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5887                 if (_ptr_previous_names) {
5888                         NDR_PULL_ALLOC(ndr, r->previous_names);
5889                 } else {
5890                         r->previous_names = NULL;
5891                 }
5892                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
5893                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
5894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
5895                 if (_ptr_manufacturer_name) {
5896                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
5897                 } else {
5898                         r->manufacturer_name = NULL;
5899                 }
5900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
5901                 if (_ptr_manufacturer_url) {
5902                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
5903                 } else {
5904                         r->manufacturer_url = NULL;
5905                 }
5906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
5907                 if (_ptr_hardware_id) {
5908                         NDR_PULL_ALLOC(ndr, r->hardware_id);
5909                 } else {
5910                         r->hardware_id = NULL;
5911                 }
5912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
5913                 if (_ptr_provider) {
5914                         NDR_PULL_ALLOC(ndr, r->provider);
5915                 } else {
5916                         r->provider = NULL;
5917                 }
5918         }
5919         if (ndr_flags & NDR_BUFFERS) {
5920                 if (r->driver_name) {
5921                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5922                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5925                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5926                                 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));
5927                         }
5928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5929                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5931                 }
5932                 if (r->architecture) {
5933                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5934                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5937                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5938                                 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));
5939                         }
5940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5943                 }
5944                 if (r->driver_path) {
5945                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5946                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5947                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5948                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5949                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5950                                 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));
5951                         }
5952                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5953                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5955                 }
5956                 if (r->data_file) {
5957                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5958                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5961                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5962                                 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));
5963                         }
5964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5967                 }
5968                 if (r->config_file) {
5969                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5970                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5973                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5974                                 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));
5975                         }
5976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5979                 }
5980                 if (r->help_file) {
5981                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5982                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5985                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5986                                 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));
5987                         }
5988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5991                 }
5992                 if (r->monitor_name) {
5993                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5994                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5997                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5998                                 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));
5999                         }
6000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6001                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6003                 }
6004                 if (r->default_datatype) {
6005                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6006                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6009                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6010                                 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));
6011                         }
6012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6015                 }
6016                 if (r->dependent_files) {
6017                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6018                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6019                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6021                 }
6022                 if (r->previous_names) {
6023                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6024                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6025                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6027                 }
6028                 if (r->manufacturer_name) {
6029                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6030                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6033                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6034                                 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));
6035                         }
6036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6039                 }
6040                 if (r->manufacturer_url) {
6041                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6042                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6045                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6046                                 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));
6047                         }
6048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6049                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6051                 }
6052                 if (r->hardware_id) {
6053                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6054                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6057                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6058                                 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));
6059                         }
6060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6063                 }
6064                 if (r->provider) {
6065                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6066                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6069                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6070                                 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));
6071                         }
6072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6075                 }
6076         }
6077         return NDR_ERR_SUCCESS;
6078 }
6079
6080 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
6081 {
6082         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
6083         ndr->depth++;
6084         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6085         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6086         ndr->depth++;
6087         if (r->driver_name) {
6088                 ndr_print_string(ndr, "driver_name", r->driver_name);
6089         }
6090         ndr->depth--;
6091         ndr_print_ptr(ndr, "architecture", r->architecture);
6092         ndr->depth++;
6093         if (r->architecture) {
6094                 ndr_print_string(ndr, "architecture", r->architecture);
6095         }
6096         ndr->depth--;
6097         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6098         ndr->depth++;
6099         if (r->driver_path) {
6100                 ndr_print_string(ndr, "driver_path", r->driver_path);
6101         }
6102         ndr->depth--;
6103         ndr_print_ptr(ndr, "data_file", r->data_file);
6104         ndr->depth++;
6105         if (r->data_file) {
6106                 ndr_print_string(ndr, "data_file", r->data_file);
6107         }
6108         ndr->depth--;
6109         ndr_print_ptr(ndr, "config_file", r->config_file);
6110         ndr->depth++;
6111         if (r->config_file) {
6112                 ndr_print_string(ndr, "config_file", r->config_file);
6113         }
6114         ndr->depth--;
6115         ndr_print_ptr(ndr, "help_file", r->help_file);
6116         ndr->depth++;
6117         if (r->help_file) {
6118                 ndr_print_string(ndr, "help_file", r->help_file);
6119         }
6120         ndr->depth--;
6121         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6122         ndr->depth++;
6123         if (r->monitor_name) {
6124                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6125         }
6126         ndr->depth--;
6127         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6128         ndr->depth++;
6129         if (r->default_datatype) {
6130                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6131         }
6132         ndr->depth--;
6133         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);
6134         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6135         ndr->depth++;
6136         if (r->dependent_files) {
6137                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6138         }
6139         ndr->depth--;
6140         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);
6141         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6142         ndr->depth++;
6143         if (r->previous_names) {
6144                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6145         }
6146         ndr->depth--;
6147         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6148         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6149         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6150         ndr->depth++;
6151         if (r->manufacturer_name) {
6152                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6153         }
6154         ndr->depth--;
6155         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6156         ndr->depth++;
6157         if (r->manufacturer_url) {
6158                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6159         }
6160         ndr->depth--;
6161         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6162         ndr->depth++;
6163         if (r->hardware_id) {
6164                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6165         }
6166         ndr->depth--;
6167         ndr_print_ptr(ndr, "provider", r->provider);
6168         ndr->depth++;
6169         if (r->provider) {
6170                 ndr_print_string(ndr, "provider", r->provider);
6171         }
6172         ndr->depth--;
6173         ndr->depth--;
6174 }
6175
6176 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
6177 {
6178         if (ndr_flags & NDR_SCALARS) {
6179                 NDR_CHECK(ndr_push_align(ndr, 8));
6180                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
6187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
6188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
6189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6190                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
6191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
6193                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
6194                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
6195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
6196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
6197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
6198                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
6199                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
6200                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
6201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
6203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
6204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
6205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
6207                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
6208                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
6209         }
6210         if (ndr_flags & NDR_BUFFERS) {
6211                 if (r->driver_name) {
6212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6213                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6215                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6216                 }
6217                 if (r->architecture) {
6218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6221                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6222                 }
6223                 if (r->driver_path) {
6224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6228                 }
6229                 if (r->data_file) {
6230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6233                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6234                 }
6235                 if (r->config_file) {
6236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6239                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6240                 }
6241                 if (r->help_file) {
6242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6245                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6246                 }
6247                 if (r->monitor_name) {
6248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6252                 }
6253                 if (r->default_datatype) {
6254                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6258                 }
6259                 if (r->dependent_files) {
6260                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6261                 }
6262                 if (r->previous_names) {
6263                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6264                 }
6265                 if (r->manufacturer_name) {
6266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6270                 }
6271                 if (r->manufacturer_url) {
6272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6276                 }
6277                 if (r->hardware_id) {
6278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6282                 }
6283                 if (r->provider) {
6284                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, 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->provider, CH_UTF16)));
6287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6288                 }
6289                 if (r->print_processor) {
6290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6293                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6294                 }
6295                 if (r->vendor_setup) {
6296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6300                 }
6301                 if (r->color_profiles) {
6302                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6303                 }
6304                 if (r->inf_path) {
6305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6306                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6307                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6308                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6309                 }
6310                 if (r->core_driver_dependencies) {
6311                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6312                 }
6313         }
6314         return NDR_ERR_SUCCESS;
6315 }
6316
6317 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
6318 {
6319         uint32_t _ptr_driver_name;
6320         TALLOC_CTX *_mem_save_driver_name_0;
6321         uint32_t _ptr_architecture;
6322         TALLOC_CTX *_mem_save_architecture_0;
6323         uint32_t _ptr_driver_path;
6324         TALLOC_CTX *_mem_save_driver_path_0;
6325         uint32_t _ptr_data_file;
6326         TALLOC_CTX *_mem_save_data_file_0;
6327         uint32_t _ptr_config_file;
6328         TALLOC_CTX *_mem_save_config_file_0;
6329         uint32_t _ptr_help_file;
6330         TALLOC_CTX *_mem_save_help_file_0;
6331         uint32_t _ptr_monitor_name;
6332         TALLOC_CTX *_mem_save_monitor_name_0;
6333         uint32_t _ptr_default_datatype;
6334         TALLOC_CTX *_mem_save_default_datatype_0;
6335         uint32_t _ptr_dependent_files;
6336         TALLOC_CTX *_mem_save_dependent_files_0;
6337         uint32_t _ptr_previous_names;
6338         TALLOC_CTX *_mem_save_previous_names_0;
6339         uint32_t _ptr_manufacturer_name;
6340         TALLOC_CTX *_mem_save_manufacturer_name_0;
6341         uint32_t _ptr_manufacturer_url;
6342         TALLOC_CTX *_mem_save_manufacturer_url_0;
6343         uint32_t _ptr_hardware_id;
6344         TALLOC_CTX *_mem_save_hardware_id_0;
6345         uint32_t _ptr_provider;
6346         TALLOC_CTX *_mem_save_provider_0;
6347         uint32_t _ptr_print_processor;
6348         TALLOC_CTX *_mem_save_print_processor_0;
6349         uint32_t _ptr_vendor_setup;
6350         TALLOC_CTX *_mem_save_vendor_setup_0;
6351         uint32_t _ptr_color_profiles;
6352         TALLOC_CTX *_mem_save_color_profiles_0;
6353         uint32_t _ptr_inf_path;
6354         TALLOC_CTX *_mem_save_inf_path_0;
6355         uint32_t _ptr_core_driver_dependencies;
6356         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
6357         if (ndr_flags & NDR_SCALARS) {
6358                 NDR_CHECK(ndr_pull_align(ndr, 8));
6359                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6361                 if (_ptr_driver_name) {
6362                         NDR_PULL_ALLOC(ndr, r->driver_name);
6363                 } else {
6364                         r->driver_name = NULL;
6365                 }
6366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6367                 if (_ptr_architecture) {
6368                         NDR_PULL_ALLOC(ndr, r->architecture);
6369                 } else {
6370                         r->architecture = NULL;
6371                 }
6372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6373                 if (_ptr_driver_path) {
6374                         NDR_PULL_ALLOC(ndr, r->driver_path);
6375                 } else {
6376                         r->driver_path = NULL;
6377                 }
6378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6379                 if (_ptr_data_file) {
6380                         NDR_PULL_ALLOC(ndr, r->data_file);
6381                 } else {
6382                         r->data_file = NULL;
6383                 }
6384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6385                 if (_ptr_config_file) {
6386                         NDR_PULL_ALLOC(ndr, r->config_file);
6387                 } else {
6388                         r->config_file = NULL;
6389                 }
6390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
6391                 if (_ptr_help_file) {
6392                         NDR_PULL_ALLOC(ndr, r->help_file);
6393                 } else {
6394                         r->help_file = NULL;
6395                 }
6396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
6397                 if (_ptr_monitor_name) {
6398                         NDR_PULL_ALLOC(ndr, r->monitor_name);
6399                 } else {
6400                         r->monitor_name = NULL;
6401                 }
6402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
6403                 if (_ptr_default_datatype) {
6404                         NDR_PULL_ALLOC(ndr, r->default_datatype);
6405                 } else {
6406                         r->default_datatype = NULL;
6407                 }
6408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
6409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
6410                 if (_ptr_dependent_files) {
6411                         NDR_PULL_ALLOC(ndr, r->dependent_files);
6412                 } else {
6413                         r->dependent_files = NULL;
6414                 }
6415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
6416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
6417                 if (_ptr_previous_names) {
6418                         NDR_PULL_ALLOC(ndr, r->previous_names);
6419                 } else {
6420                         r->previous_names = NULL;
6421                 }
6422                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
6423                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
6424                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
6425                 if (_ptr_manufacturer_name) {
6426                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
6427                 } else {
6428                         r->manufacturer_name = NULL;
6429                 }
6430                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
6431                 if (_ptr_manufacturer_url) {
6432                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
6433                 } else {
6434                         r->manufacturer_url = NULL;
6435                 }
6436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
6437                 if (_ptr_hardware_id) {
6438                         NDR_PULL_ALLOC(ndr, r->hardware_id);
6439                 } else {
6440                         r->hardware_id = NULL;
6441                 }
6442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
6443                 if (_ptr_provider) {
6444                         NDR_PULL_ALLOC(ndr, r->provider);
6445                 } else {
6446                         r->provider = NULL;
6447                 }
6448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
6449                 if (_ptr_print_processor) {
6450                         NDR_PULL_ALLOC(ndr, r->print_processor);
6451                 } else {
6452                         r->print_processor = NULL;
6453                 }
6454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
6455                 if (_ptr_vendor_setup) {
6456                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
6457                 } else {
6458                         r->vendor_setup = NULL;
6459                 }
6460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
6461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
6462                 if (_ptr_color_profiles) {
6463                         NDR_PULL_ALLOC(ndr, r->color_profiles);
6464                 } else {
6465                         r->color_profiles = NULL;
6466                 }
6467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
6468                 if (_ptr_inf_path) {
6469                         NDR_PULL_ALLOC(ndr, r->inf_path);
6470                 } else {
6471                         r->inf_path = NULL;
6472                 }
6473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
6474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
6475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
6476                 if (_ptr_core_driver_dependencies) {
6477                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
6478                 } else {
6479                         r->core_driver_dependencies = NULL;
6480                 }
6481                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
6482                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
6483         }
6484         if (ndr_flags & NDR_BUFFERS) {
6485                 if (r->driver_name) {
6486                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6487                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6490                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6491                                 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));
6492                         }
6493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6496                 }
6497                 if (r->architecture) {
6498                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6499                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6500                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6501                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6502                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6503                                 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));
6504                         }
6505                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6506                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6508                 }
6509                 if (r->driver_path) {
6510                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6511                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6512                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6513                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6514                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6515                                 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));
6516                         }
6517                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6518                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6520                 }
6521                 if (r->data_file) {
6522                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6523                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6524                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6525                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6526                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6527                                 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));
6528                         }
6529                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6530                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6532                 }
6533                 if (r->config_file) {
6534                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6535                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6536                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6537                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6538                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6539                                 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));
6540                         }
6541                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6542                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6544                 }
6545                 if (r->help_file) {
6546                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6547                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
6548                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
6549                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
6550                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
6551                                 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));
6552                         }
6553                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
6554                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
6555                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
6556                 }
6557                 if (r->monitor_name) {
6558                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6559                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6560                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6561                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6562                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6563                                 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));
6564                         }
6565                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6566                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6568                 }
6569                 if (r->default_datatype) {
6570                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6571                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6572                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6573                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6574                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6575                                 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));
6576                         }
6577                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6578                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6579                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6580                 }
6581                 if (r->dependent_files) {
6582                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6583                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6584                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6586                 }
6587                 if (r->previous_names) {
6588                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6589                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6590                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6592                 }
6593                 if (r->manufacturer_name) {
6594                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6595                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6598                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6599                                 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));
6600                         }
6601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6604                 }
6605                 if (r->manufacturer_url) {
6606                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6607                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6610                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6611                                 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));
6612                         }
6613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6616                 }
6617                 if (r->hardware_id) {
6618                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6619                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6622                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6623                                 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));
6624                         }
6625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6628                 }
6629                 if (r->provider) {
6630                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6631                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6634                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6635                                 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));
6636                         }
6637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6640                 }
6641                 if (r->print_processor) {
6642                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6643                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6645                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6646                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6647                                 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));
6648                         }
6649                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6650                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6652                 }
6653                 if (r->vendor_setup) {
6654                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
6655                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
6656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
6657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
6658                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
6659                                 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));
6660                         }
6661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
6662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
6663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
6664                 }
6665                 if (r->color_profiles) {
6666                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
6667                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
6668                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
6670                 }
6671                 if (r->inf_path) {
6672                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6673                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
6674                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
6675                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
6676                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
6677                                 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));
6678                         }
6679                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
6680                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
6681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
6682                 }
6683                 if (r->core_driver_dependencies) {
6684                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
6685                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
6686                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
6688                 }
6689         }
6690         return NDR_ERR_SUCCESS;
6691 }
6692
6693 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
6694 {
6695         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
6696         ndr->depth++;
6697         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6698         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6699         ndr->depth++;
6700         if (r->driver_name) {
6701                 ndr_print_string(ndr, "driver_name", r->driver_name);
6702         }
6703         ndr->depth--;
6704         ndr_print_ptr(ndr, "architecture", r->architecture);
6705         ndr->depth++;
6706         if (r->architecture) {
6707                 ndr_print_string(ndr, "architecture", r->architecture);
6708         }
6709         ndr->depth--;
6710         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6711         ndr->depth++;
6712         if (r->driver_path) {
6713                 ndr_print_string(ndr, "driver_path", r->driver_path);
6714         }
6715         ndr->depth--;
6716         ndr_print_ptr(ndr, "data_file", r->data_file);
6717         ndr->depth++;
6718         if (r->data_file) {
6719                 ndr_print_string(ndr, "data_file", r->data_file);
6720         }
6721         ndr->depth--;
6722         ndr_print_ptr(ndr, "config_file", r->config_file);
6723         ndr->depth++;
6724         if (r->config_file) {
6725                 ndr_print_string(ndr, "config_file", r->config_file);
6726         }
6727         ndr->depth--;
6728         ndr_print_ptr(ndr, "help_file", r->help_file);
6729         ndr->depth++;
6730         if (r->help_file) {
6731                 ndr_print_string(ndr, "help_file", r->help_file);
6732         }
6733         ndr->depth--;
6734         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6735         ndr->depth++;
6736         if (r->monitor_name) {
6737                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6738         }
6739         ndr->depth--;
6740         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6741         ndr->depth++;
6742         if (r->default_datatype) {
6743                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6744         }
6745         ndr->depth--;
6746         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);
6747         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6748         ndr->depth++;
6749         if (r->dependent_files) {
6750                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6751         }
6752         ndr->depth--;
6753         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);
6754         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6755         ndr->depth++;
6756         if (r->previous_names) {
6757                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6758         }
6759         ndr->depth--;
6760         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6761         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6762         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6763         ndr->depth++;
6764         if (r->manufacturer_name) {
6765                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6766         }
6767         ndr->depth--;
6768         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6769         ndr->depth++;
6770         if (r->manufacturer_url) {
6771                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6772         }
6773         ndr->depth--;
6774         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6775         ndr->depth++;
6776         if (r->hardware_id) {
6777                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6778         }
6779         ndr->depth--;
6780         ndr_print_ptr(ndr, "provider", r->provider);
6781         ndr->depth++;
6782         if (r->provider) {
6783                 ndr_print_string(ndr, "provider", r->provider);
6784         }
6785         ndr->depth--;
6786         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6787         ndr->depth++;
6788         if (r->print_processor) {
6789                 ndr_print_string(ndr, "print_processor", r->print_processor);
6790         }
6791         ndr->depth--;
6792         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
6793         ndr->depth++;
6794         if (r->vendor_setup) {
6795                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
6796         }
6797         ndr->depth--;
6798         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);
6799         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
6800         ndr->depth++;
6801         if (r->color_profiles) {
6802                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
6803         }
6804         ndr->depth--;
6805         ndr_print_ptr(ndr, "inf_path", r->inf_path);
6806         ndr->depth++;
6807         if (r->inf_path) {
6808                 ndr_print_string(ndr, "inf_path", r->inf_path);
6809         }
6810         ndr->depth--;
6811         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
6812         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);
6813         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6814         ndr->depth++;
6815         if (r->core_driver_dependencies) {
6816                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6817         }
6818         ndr->depth--;
6819         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
6820         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
6821         ndr->depth--;
6822 }
6823
6824 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
6825 {
6826         if (ndr_flags & NDR_SCALARS) {
6827                 int level = ndr_push_get_switch_value(ndr, r);
6828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6829                 switch (level) {
6830                         case 1: {
6831                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6832                         break; }
6833
6834                         case 2: {
6835                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6836                         break; }
6837
6838                         case 3: {
6839                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6840                         break; }
6841
6842                         case 4: {
6843                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6844                         break; }
6845
6846                         case 6: {
6847                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6848                         break; }
6849
6850                         case 8: {
6851                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6852                         break; }
6853
6854                         default:
6855                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6856                 }
6857         }
6858         if (ndr_flags & NDR_BUFFERS) {
6859                 int level = ndr_push_get_switch_value(ndr, r);
6860                 switch (level) {
6861                         case 1:
6862                                 if (r->info1) {
6863                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6864                                 }
6865                         break;
6866
6867                         case 2:
6868                                 if (r->info2) {
6869                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6870                                 }
6871                         break;
6872
6873                         case 3:
6874                                 if (r->info3) {
6875                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6876                                 }
6877                         break;
6878
6879                         case 4:
6880                                 if (r->info4) {
6881                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6882                                 }
6883                         break;
6884
6885                         case 6:
6886                                 if (r->info6) {
6887                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
6888                                 }
6889                         break;
6890
6891                         case 8:
6892                                 if (r->info8) {
6893                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6894                                 }
6895                         break;
6896
6897                         default:
6898                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6899                 }
6900         }
6901         return NDR_ERR_SUCCESS;
6902 }
6903
6904 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
6905 {
6906         int level;
6907         uint32_t _level;
6908         TALLOC_CTX *_mem_save_info1_0;
6909         TALLOC_CTX *_mem_save_info2_0;
6910         TALLOC_CTX *_mem_save_info3_0;
6911         TALLOC_CTX *_mem_save_info4_0;
6912         TALLOC_CTX *_mem_save_info6_0;
6913         TALLOC_CTX *_mem_save_info8_0;
6914         level = ndr_pull_get_switch_value(ndr, r);
6915         if (ndr_flags & NDR_SCALARS) {
6916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6917                 if (_level != level) {
6918                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6919                 }
6920                 switch (level) {
6921                         case 1: {
6922                                 uint32_t _ptr_info1;
6923                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6924                                 if (_ptr_info1) {
6925                                         NDR_PULL_ALLOC(ndr, r->info1);
6926                                 } else {
6927                                         r->info1 = NULL;
6928                                 }
6929                         break; }
6930
6931                         case 2: {
6932                                 uint32_t _ptr_info2;
6933                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6934                                 if (_ptr_info2) {
6935                                         NDR_PULL_ALLOC(ndr, r->info2);
6936                                 } else {
6937                                         r->info2 = NULL;
6938                                 }
6939                         break; }
6940
6941                         case 3: {
6942                                 uint32_t _ptr_info3;
6943                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6944                                 if (_ptr_info3) {
6945                                         NDR_PULL_ALLOC(ndr, r->info3);
6946                                 } else {
6947                                         r->info3 = NULL;
6948                                 }
6949                         break; }
6950
6951                         case 4: {
6952                                 uint32_t _ptr_info4;
6953                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6954                                 if (_ptr_info4) {
6955                                         NDR_PULL_ALLOC(ndr, r->info4);
6956                                 } else {
6957                                         r->info4 = NULL;
6958                                 }
6959                         break; }
6960
6961                         case 6: {
6962                                 uint32_t _ptr_info6;
6963                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
6964                                 if (_ptr_info6) {
6965                                         NDR_PULL_ALLOC(ndr, r->info6);
6966                                 } else {
6967                                         r->info6 = NULL;
6968                                 }
6969                         break; }
6970
6971                         case 8: {
6972                                 uint32_t _ptr_info8;
6973                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
6974                                 if (_ptr_info8) {
6975                                         NDR_PULL_ALLOC(ndr, r->info8);
6976                                 } else {
6977                                         r->info8 = NULL;
6978                                 }
6979                         break; }
6980
6981                         default:
6982                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6983                 }
6984         }
6985         if (ndr_flags & NDR_BUFFERS) {
6986                 switch (level) {
6987                         case 1:
6988                                 if (r->info1) {
6989                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6990                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6991                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6992                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6993                                 }
6994                         break;
6995
6996                         case 2:
6997                                 if (r->info2) {
6998                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6999                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7000                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7001                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7002                                 }
7003                         break;
7004
7005                         case 3:
7006                                 if (r->info3) {
7007                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7008                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7009                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
7010                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7011                                 }
7012                         break;
7013
7014                         case 4:
7015                                 if (r->info4) {
7016                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7017                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7018                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7019                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7020                                 }
7021                         break;
7022
7023                         case 6:
7024                                 if (r->info6) {
7025                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7026                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7027                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
7028                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7029                                 }
7030                         break;
7031
7032                         case 8:
7033                                 if (r->info8) {
7034                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7036                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7037                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7038                                 }
7039                         break;
7040
7041                         default:
7042                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7043                 }
7044         }
7045         return NDR_ERR_SUCCESS;
7046 }
7047
7048 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
7049 {
7050         int level;
7051         level = ndr_print_get_switch_value(ndr, r);
7052         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
7053         switch (level) {
7054                 case 1:
7055                         ndr_print_ptr(ndr, "info1", r->info1);
7056                         ndr->depth++;
7057                         if (r->info1) {
7058                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
7059                         }
7060                         ndr->depth--;
7061                 break;
7062
7063                 case 2:
7064                         ndr_print_ptr(ndr, "info2", r->info2);
7065                         ndr->depth++;
7066                         if (r->info2) {
7067                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
7068                         }
7069                         ndr->depth--;
7070                 break;
7071
7072                 case 3:
7073                         ndr_print_ptr(ndr, "info3", r->info3);
7074                         ndr->depth++;
7075                         if (r->info3) {
7076                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
7077                         }
7078                         ndr->depth--;
7079                 break;
7080
7081                 case 4:
7082                         ndr_print_ptr(ndr, "info4", r->info4);
7083                         ndr->depth++;
7084                         if (r->info4) {
7085                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
7086                         }
7087                         ndr->depth--;
7088                 break;
7089
7090                 case 6:
7091                         ndr_print_ptr(ndr, "info6", r->info6);
7092                         ndr->depth++;
7093                         if (r->info6) {
7094                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
7095                         }
7096                         ndr->depth--;
7097                 break;
7098
7099                 case 8:
7100                         ndr_print_ptr(ndr, "info8", r->info8);
7101                         ndr->depth++;
7102                         if (r->info8) {
7103                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
7104                         }
7105                         ndr->depth--;
7106                 break;
7107
7108                 default:
7109                         ndr_print_bad_level(ndr, name, level);
7110         }
7111 }
7112
7113 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
7114 {
7115         if (ndr_flags & NDR_SCALARS) {
7116                 NDR_CHECK(ndr_push_align(ndr, 4));
7117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7118                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7119                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7120         }
7121         if (ndr_flags & NDR_BUFFERS) {
7122                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7123         }
7124         return NDR_ERR_SUCCESS;
7125 }
7126
7127 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
7128 {
7129         if (ndr_flags & NDR_SCALARS) {
7130                 NDR_CHECK(ndr_pull_align(ndr, 4));
7131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7132                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7133                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7134         }
7135         if (ndr_flags & NDR_BUFFERS) {
7136                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7137         }
7138         return NDR_ERR_SUCCESS;
7139 }
7140
7141 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
7142 {
7143         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
7144         ndr->depth++;
7145         ndr_print_uint32(ndr, "level", r->level);
7146         ndr_print_set_switch_value(ndr, &r->info, r->level);
7147         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
7148         ndr->depth--;
7149 }
7150
7151 static enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
7152 {
7153         if (ndr_flags & NDR_SCALARS) {
7154                 NDR_CHECK(ndr_push_align(ndr, 4));
7155                 {
7156                         uint32_t _flags_save_string = ndr->flags;
7157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7158                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7159                         ndr->flags = _flags_save_string;
7160                 }
7161         }
7162         if (ndr_flags & NDR_BUFFERS) {
7163                 {
7164                         uint32_t _flags_save_string = ndr->flags;
7165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7166                         if (r->driver_name) {
7167                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7168                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7169                         }
7170                         ndr->flags = _flags_save_string;
7171                 }
7172         }
7173         return NDR_ERR_SUCCESS;
7174 }
7175
7176 static enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
7177 {
7178         uint32_t _ptr_driver_name;
7179         TALLOC_CTX *_mem_save_driver_name_0;
7180         if (ndr_flags & NDR_SCALARS) {
7181                 NDR_CHECK(ndr_pull_align(ndr, 4));
7182                 {
7183                         uint32_t _flags_save_string = ndr->flags;
7184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7185                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7186                         if (_ptr_driver_name) {
7187                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7188                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7189                         } else {
7190                                 r->driver_name = NULL;
7191                         }
7192                         ndr->flags = _flags_save_string;
7193                 }
7194         }
7195         if (ndr_flags & NDR_BUFFERS) {
7196                 {
7197                         uint32_t _flags_save_string = ndr->flags;
7198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7199                         if (r->driver_name) {
7200                                 uint32_t _relative_save_offset;
7201                                 _relative_save_offset = ndr->offset;
7202                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7203                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7204                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7205                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7206                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7207                                 ndr->offset = _relative_save_offset;
7208                         }
7209                         ndr->flags = _flags_save_string;
7210                 }
7211         }
7212         return NDR_ERR_SUCCESS;
7213 }
7214
7215 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
7216 {
7217         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
7218         ndr->depth++;
7219         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7220         ndr->depth++;
7221         if (r->driver_name) {
7222                 ndr_print_string(ndr, "driver_name", r->driver_name);
7223         }
7224         ndr->depth--;
7225         ndr->depth--;
7226 }
7227
7228 static enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
7229 {
7230         if (ndr_flags & NDR_SCALARS) {
7231                 NDR_CHECK(ndr_push_align(ndr, 4));
7232                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7233                 {
7234                         uint32_t _flags_save_string = ndr->flags;
7235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7236                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7237                         ndr->flags = _flags_save_string;
7238                 }
7239                 {
7240                         uint32_t _flags_save_string = ndr->flags;
7241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7242                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7243                         ndr->flags = _flags_save_string;
7244                 }
7245                 {
7246                         uint32_t _flags_save_string = ndr->flags;
7247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7248                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7249                         ndr->flags = _flags_save_string;
7250                 }
7251                 {
7252                         uint32_t _flags_save_string = ndr->flags;
7253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7255                         ndr->flags = _flags_save_string;
7256                 }
7257                 {
7258                         uint32_t _flags_save_string = ndr->flags;
7259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7260                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7261                         ndr->flags = _flags_save_string;
7262                 }
7263         }
7264         if (ndr_flags & NDR_BUFFERS) {
7265                 {
7266                         uint32_t _flags_save_string = ndr->flags;
7267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7268                         if (r->driver_name) {
7269                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7270                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7271                         }
7272                         ndr->flags = _flags_save_string;
7273                 }
7274                 {
7275                         uint32_t _flags_save_string = ndr->flags;
7276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7277                         if (r->architecture) {
7278                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7279                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7280                         }
7281                         ndr->flags = _flags_save_string;
7282                 }
7283                 {
7284                         uint32_t _flags_save_string = ndr->flags;
7285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7286                         if (r->driver_path) {
7287                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7288                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7289                         }
7290                         ndr->flags = _flags_save_string;
7291                 }
7292                 {
7293                         uint32_t _flags_save_string = ndr->flags;
7294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7295                         if (r->data_file) {
7296                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7297                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7298                         }
7299                         ndr->flags = _flags_save_string;
7300                 }
7301                 {
7302                         uint32_t _flags_save_string = ndr->flags;
7303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7304                         if (r->config_file) {
7305                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7306                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7307                         }
7308                         ndr->flags = _flags_save_string;
7309                 }
7310         }
7311         return NDR_ERR_SUCCESS;
7312 }
7313
7314 static enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
7315 {
7316         uint32_t _ptr_driver_name;
7317         TALLOC_CTX *_mem_save_driver_name_0;
7318         uint32_t _ptr_architecture;
7319         TALLOC_CTX *_mem_save_architecture_0;
7320         uint32_t _ptr_driver_path;
7321         TALLOC_CTX *_mem_save_driver_path_0;
7322         uint32_t _ptr_data_file;
7323         TALLOC_CTX *_mem_save_data_file_0;
7324         uint32_t _ptr_config_file;
7325         TALLOC_CTX *_mem_save_config_file_0;
7326         if (ndr_flags & NDR_SCALARS) {
7327                 NDR_CHECK(ndr_pull_align(ndr, 4));
7328                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7329                 {
7330                         uint32_t _flags_save_string = ndr->flags;
7331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7332                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7333                         if (_ptr_driver_name) {
7334                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7335                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7336                         } else {
7337                                 r->driver_name = NULL;
7338                         }
7339                         ndr->flags = _flags_save_string;
7340                 }
7341                 {
7342                         uint32_t _flags_save_string = ndr->flags;
7343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7344                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7345                         if (_ptr_architecture) {
7346                                 NDR_PULL_ALLOC(ndr, r->architecture);
7347                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7348                         } else {
7349                                 r->architecture = NULL;
7350                         }
7351                         ndr->flags = _flags_save_string;
7352                 }
7353                 {
7354                         uint32_t _flags_save_string = ndr->flags;
7355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7356                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7357                         if (_ptr_driver_path) {
7358                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7359                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7360                         } else {
7361                                 r->driver_path = NULL;
7362                         }
7363                         ndr->flags = _flags_save_string;
7364                 }
7365                 {
7366                         uint32_t _flags_save_string = ndr->flags;
7367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7368                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7369                         if (_ptr_data_file) {
7370                                 NDR_PULL_ALLOC(ndr, r->data_file);
7371                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7372                         } else {
7373                                 r->data_file = NULL;
7374                         }
7375                         ndr->flags = _flags_save_string;
7376                 }
7377                 {
7378                         uint32_t _flags_save_string = ndr->flags;
7379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7380                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7381                         if (_ptr_config_file) {
7382                                 NDR_PULL_ALLOC(ndr, r->config_file);
7383                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7384                         } else {
7385                                 r->config_file = NULL;
7386                         }
7387                         ndr->flags = _flags_save_string;
7388                 }
7389         }
7390         if (ndr_flags & NDR_BUFFERS) {
7391                 {
7392                         uint32_t _flags_save_string = ndr->flags;
7393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7394                         if (r->driver_name) {
7395                                 uint32_t _relative_save_offset;
7396                                 _relative_save_offset = ndr->offset;
7397                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7398                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7399                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7400                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7401                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7402                                 ndr->offset = _relative_save_offset;
7403                         }
7404                         ndr->flags = _flags_save_string;
7405                 }
7406                 {
7407                         uint32_t _flags_save_string = ndr->flags;
7408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7409                         if (r->architecture) {
7410                                 uint32_t _relative_save_offset;
7411                                 _relative_save_offset = ndr->offset;
7412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7413                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7414                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7417                                 ndr->offset = _relative_save_offset;
7418                         }
7419                         ndr->flags = _flags_save_string;
7420                 }
7421                 {
7422                         uint32_t _flags_save_string = ndr->flags;
7423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7424                         if (r->driver_path) {
7425                                 uint32_t _relative_save_offset;
7426                                 _relative_save_offset = ndr->offset;
7427                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7428                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7429                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7430                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7431                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7432                                 ndr->offset = _relative_save_offset;
7433                         }
7434                         ndr->flags = _flags_save_string;
7435                 }
7436                 {
7437                         uint32_t _flags_save_string = ndr->flags;
7438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7439                         if (r->data_file) {
7440                                 uint32_t _relative_save_offset;
7441                                 _relative_save_offset = ndr->offset;
7442                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7443                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7444                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7445                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7446                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7447                                 ndr->offset = _relative_save_offset;
7448                         }
7449                         ndr->flags = _flags_save_string;
7450                 }
7451                 {
7452                         uint32_t _flags_save_string = ndr->flags;
7453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7454                         if (r->config_file) {
7455                                 uint32_t _relative_save_offset;
7456                                 _relative_save_offset = ndr->offset;
7457                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7458                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7459                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7460                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7461                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7462                                 ndr->offset = _relative_save_offset;
7463                         }
7464                         ndr->flags = _flags_save_string;
7465                 }
7466         }
7467         return NDR_ERR_SUCCESS;
7468 }
7469
7470 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
7471 {
7472         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
7473         ndr->depth++;
7474         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7475         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7476         ndr->depth++;
7477         if (r->driver_name) {
7478                 ndr_print_string(ndr, "driver_name", r->driver_name);
7479         }
7480         ndr->depth--;
7481         ndr_print_ptr(ndr, "architecture", r->architecture);
7482         ndr->depth++;
7483         if (r->architecture) {
7484                 ndr_print_string(ndr, "architecture", r->architecture);
7485         }
7486         ndr->depth--;
7487         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7488         ndr->depth++;
7489         if (r->driver_path) {
7490                 ndr_print_string(ndr, "driver_path", r->driver_path);
7491         }
7492         ndr->depth--;
7493         ndr_print_ptr(ndr, "data_file", r->data_file);
7494         ndr->depth++;
7495         if (r->data_file) {
7496                 ndr_print_string(ndr, "data_file", r->data_file);
7497         }
7498         ndr->depth--;
7499         ndr_print_ptr(ndr, "config_file", r->config_file);
7500         ndr->depth++;
7501         if (r->config_file) {
7502                 ndr_print_string(ndr, "config_file", r->config_file);
7503         }
7504         ndr->depth--;
7505         ndr->depth--;
7506 }
7507
7508 static enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
7509 {
7510         if (ndr_flags & NDR_SCALARS) {
7511                 NDR_CHECK(ndr_push_align(ndr, 4));
7512                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7513                 {
7514                         uint32_t _flags_save_string = ndr->flags;
7515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7516                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7517                         ndr->flags = _flags_save_string;
7518                 }
7519                 {
7520                         uint32_t _flags_save_string = ndr->flags;
7521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7522                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7523                         ndr->flags = _flags_save_string;
7524                 }
7525                 {
7526                         uint32_t _flags_save_string = ndr->flags;
7527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7528                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7529                         ndr->flags = _flags_save_string;
7530                 }
7531                 {
7532                         uint32_t _flags_save_string = ndr->flags;
7533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7534                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7535                         ndr->flags = _flags_save_string;
7536                 }
7537                 {
7538                         uint32_t _flags_save_string = ndr->flags;
7539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7540                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7541                         ndr->flags = _flags_save_string;
7542                 }
7543                 {
7544                         uint32_t _flags_save_string = ndr->flags;
7545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7546                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
7547                         ndr->flags = _flags_save_string;
7548                 }
7549                 {
7550                         uint32_t _flags_save_string_array = ndr->flags;
7551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7552                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
7553                         ndr->flags = _flags_save_string_array;
7554                 }
7555                 {
7556                         uint32_t _flags_save_string = ndr->flags;
7557                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7558                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7559                         ndr->flags = _flags_save_string;
7560                 }
7561                 {
7562                         uint32_t _flags_save_string = ndr->flags;
7563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7564                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
7565                         ndr->flags = _flags_save_string;
7566                 }
7567         }
7568         if (ndr_flags & NDR_BUFFERS) {
7569                 {
7570                         uint32_t _flags_save_string = ndr->flags;
7571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7572                         if (r->driver_name) {
7573                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7574                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7575                         }
7576                         ndr->flags = _flags_save_string;
7577                 }
7578                 {
7579                         uint32_t _flags_save_string = ndr->flags;
7580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7581                         if (r->architecture) {
7582                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7583                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7584                         }
7585                         ndr->flags = _flags_save_string;
7586                 }
7587                 {
7588                         uint32_t _flags_save_string = ndr->flags;
7589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7590                         if (r->driver_path) {
7591                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7592                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7593                         }
7594                         ndr->flags = _flags_save_string;
7595                 }
7596                 {
7597                         uint32_t _flags_save_string = ndr->flags;
7598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7599                         if (r->data_file) {
7600                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7601                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7602                         }
7603                         ndr->flags = _flags_save_string;
7604                 }
7605                 {
7606                         uint32_t _flags_save_string = ndr->flags;
7607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7608                         if (r->config_file) {
7609                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7610                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7611                         }
7612                         ndr->flags = _flags_save_string;
7613                 }
7614                 {
7615                         uint32_t _flags_save_string = ndr->flags;
7616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7617                         if (r->help_file) {
7618                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
7619                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
7620                         }
7621                         ndr->flags = _flags_save_string;
7622                 }
7623                 {
7624                         uint32_t _flags_save_string_array = ndr->flags;
7625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7626                         if (r->dependent_files) {
7627                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
7628                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
7629                         }
7630                         ndr->flags = _flags_save_string_array;
7631                 }
7632                 {
7633                         uint32_t _flags_save_string = ndr->flags;
7634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7635                         if (r->monitor_name) {
7636                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7637                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7638                         }
7639                         ndr->flags = _flags_save_string;
7640                 }
7641                 {
7642                         uint32_t _flags_save_string = ndr->flags;
7643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7644                         if (r->default_datatype) {
7645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
7646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
7647                         }
7648                         ndr->flags = _flags_save_string;
7649                 }
7650         }
7651         return NDR_ERR_SUCCESS;
7652 }
7653
7654 static enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
7655 {
7656         uint32_t _ptr_driver_name;
7657         TALLOC_CTX *_mem_save_driver_name_0;
7658         uint32_t _ptr_architecture;
7659         TALLOC_CTX *_mem_save_architecture_0;
7660         uint32_t _ptr_driver_path;
7661         TALLOC_CTX *_mem_save_driver_path_0;
7662         uint32_t _ptr_data_file;
7663         TALLOC_CTX *_mem_save_data_file_0;
7664         uint32_t _ptr_config_file;
7665         TALLOC_CTX *_mem_save_config_file_0;
7666         uint32_t _ptr_help_file;
7667         TALLOC_CTX *_mem_save_help_file_0;
7668         uint32_t _ptr_dependent_files;
7669         TALLOC_CTX *_mem_save_dependent_files_0;
7670         uint32_t _ptr_monitor_name;
7671         TALLOC_CTX *_mem_save_monitor_name_0;
7672         uint32_t _ptr_default_datatype;
7673         TALLOC_CTX *_mem_save_default_datatype_0;
7674         if (ndr_flags & NDR_SCALARS) {
7675                 NDR_CHECK(ndr_pull_align(ndr, 4));
7676                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7677                 {
7678                         uint32_t _flags_save_string = ndr->flags;
7679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7681                         if (_ptr_driver_name) {
7682                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7684                         } else {
7685                                 r->driver_name = NULL;
7686                         }
7687                         ndr->flags = _flags_save_string;
7688                 }
7689                 {
7690                         uint32_t _flags_save_string = ndr->flags;
7691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7692                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7693                         if (_ptr_architecture) {
7694                                 NDR_PULL_ALLOC(ndr, r->architecture);
7695                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7696                         } else {
7697                                 r->architecture = NULL;
7698                         }
7699                         ndr->flags = _flags_save_string;
7700                 }
7701                 {
7702                         uint32_t _flags_save_string = ndr->flags;
7703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7704                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7705                         if (_ptr_driver_path) {
7706                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7707                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7708                         } else {
7709                                 r->driver_path = NULL;
7710                         }
7711                         ndr->flags = _flags_save_string;
7712                 }
7713                 {
7714                         uint32_t _flags_save_string = ndr->flags;
7715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7716                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7717                         if (_ptr_data_file) {
7718                                 NDR_PULL_ALLOC(ndr, r->data_file);
7719                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7720                         } else {
7721                                 r->data_file = NULL;
7722                         }
7723                         ndr->flags = _flags_save_string;
7724                 }
7725                 {
7726                         uint32_t _flags_save_string = ndr->flags;
7727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7728                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7729                         if (_ptr_config_file) {
7730                                 NDR_PULL_ALLOC(ndr, r->config_file);
7731                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7732                         } else {
7733                                 r->config_file = NULL;
7734                         }
7735                         ndr->flags = _flags_save_string;
7736                 }
7737                 {
7738                         uint32_t _flags_save_string = ndr->flags;
7739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7740                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7741                         if (_ptr_help_file) {
7742                                 NDR_PULL_ALLOC(ndr, r->help_file);
7743                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7744                         } else {
7745                                 r->help_file = NULL;
7746                         }
7747                         ndr->flags = _flags_save_string;
7748                 }
7749                 {
7750                         uint32_t _flags_save_string_array = ndr->flags;
7751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7752                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7753                         if (_ptr_dependent_files) {
7754                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7755                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7756                         } else {
7757                                 r->dependent_files = NULL;
7758                         }
7759                         ndr->flags = _flags_save_string_array;
7760                 }
7761                 {
7762                         uint32_t _flags_save_string = ndr->flags;
7763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7764                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7765                         if (_ptr_monitor_name) {
7766                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7767                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7768                         } else {
7769                                 r->monitor_name = NULL;
7770                         }
7771                         ndr->flags = _flags_save_string;
7772                 }
7773                 {
7774                         uint32_t _flags_save_string = ndr->flags;
7775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7777                         if (_ptr_default_datatype) {
7778                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7780                         } else {
7781                                 r->default_datatype = NULL;
7782                         }
7783                         ndr->flags = _flags_save_string;
7784                 }
7785         }
7786         if (ndr_flags & NDR_BUFFERS) {
7787                 {
7788                         uint32_t _flags_save_string = ndr->flags;
7789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7790                         if (r->driver_name) {
7791                                 uint32_t _relative_save_offset;
7792                                 _relative_save_offset = ndr->offset;
7793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7794                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7795                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7798                                 ndr->offset = _relative_save_offset;
7799                         }
7800                         ndr->flags = _flags_save_string;
7801                 }
7802                 {
7803                         uint32_t _flags_save_string = ndr->flags;
7804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7805                         if (r->architecture) {
7806                                 uint32_t _relative_save_offset;
7807                                 _relative_save_offset = ndr->offset;
7808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7809                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7810                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7813                                 ndr->offset = _relative_save_offset;
7814                         }
7815                         ndr->flags = _flags_save_string;
7816                 }
7817                 {
7818                         uint32_t _flags_save_string = ndr->flags;
7819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7820                         if (r->driver_path) {
7821                                 uint32_t _relative_save_offset;
7822                                 _relative_save_offset = ndr->offset;
7823                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7824                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7825                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7826                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7827                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7828                                 ndr->offset = _relative_save_offset;
7829                         }
7830                         ndr->flags = _flags_save_string;
7831                 }
7832                 {
7833                         uint32_t _flags_save_string = ndr->flags;
7834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7835                         if (r->data_file) {
7836                                 uint32_t _relative_save_offset;
7837                                 _relative_save_offset = ndr->offset;
7838                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7839                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7840                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7841                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7842                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7843                                 ndr->offset = _relative_save_offset;
7844                         }
7845                         ndr->flags = _flags_save_string;
7846                 }
7847                 {
7848                         uint32_t _flags_save_string = ndr->flags;
7849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7850                         if (r->config_file) {
7851                                 uint32_t _relative_save_offset;
7852                                 _relative_save_offset = ndr->offset;
7853                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7854                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7855                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7856                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7857                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7858                                 ndr->offset = _relative_save_offset;
7859                         }
7860                         ndr->flags = _flags_save_string;
7861                 }
7862                 {
7863                         uint32_t _flags_save_string = ndr->flags;
7864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7865                         if (r->help_file) {
7866                                 uint32_t _relative_save_offset;
7867                                 _relative_save_offset = ndr->offset;
7868                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7869                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7870                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7871                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7872                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7873                                 ndr->offset = _relative_save_offset;
7874                         }
7875                         ndr->flags = _flags_save_string;
7876                 }
7877                 {
7878                         uint32_t _flags_save_string_array = ndr->flags;
7879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7880                         if (r->dependent_files) {
7881                                 uint32_t _relative_save_offset;
7882                                 _relative_save_offset = ndr->offset;
7883                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7884                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7885                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7886                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7887                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7888                                 ndr->offset = _relative_save_offset;
7889                         }
7890                         ndr->flags = _flags_save_string_array;
7891                 }
7892                 {
7893                         uint32_t _flags_save_string = ndr->flags;
7894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7895                         if (r->monitor_name) {
7896                                 uint32_t _relative_save_offset;
7897                                 _relative_save_offset = ndr->offset;
7898                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7899                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7900                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7901                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7902                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7903                                 ndr->offset = _relative_save_offset;
7904                         }
7905                         ndr->flags = _flags_save_string;
7906                 }
7907                 {
7908                         uint32_t _flags_save_string = ndr->flags;
7909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7910                         if (r->default_datatype) {
7911                                 uint32_t _relative_save_offset;
7912                                 _relative_save_offset = ndr->offset;
7913                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7914                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7915                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7916                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7917                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7918                                 ndr->offset = _relative_save_offset;
7919                         }
7920                         ndr->flags = _flags_save_string;
7921                 }
7922         }
7923         return NDR_ERR_SUCCESS;
7924 }
7925
7926 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
7927 {
7928         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
7929         ndr->depth++;
7930         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7931         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7932         ndr->depth++;
7933         if (r->driver_name) {
7934                 ndr_print_string(ndr, "driver_name", r->driver_name);
7935         }
7936         ndr->depth--;
7937         ndr_print_ptr(ndr, "architecture", r->architecture);
7938         ndr->depth++;
7939         if (r->architecture) {
7940                 ndr_print_string(ndr, "architecture", r->architecture);
7941         }
7942         ndr->depth--;
7943         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7944         ndr->depth++;
7945         if (r->driver_path) {
7946                 ndr_print_string(ndr, "driver_path", r->driver_path);
7947         }
7948         ndr->depth--;
7949         ndr_print_ptr(ndr, "data_file", r->data_file);
7950         ndr->depth++;
7951         if (r->data_file) {
7952                 ndr_print_string(ndr, "data_file", r->data_file);
7953         }
7954         ndr->depth--;
7955         ndr_print_ptr(ndr, "config_file", r->config_file);
7956         ndr->depth++;
7957         if (r->config_file) {
7958                 ndr_print_string(ndr, "config_file", r->config_file);
7959         }
7960         ndr->depth--;
7961         ndr_print_ptr(ndr, "help_file", r->help_file);
7962         ndr->depth++;
7963         if (r->help_file) {
7964                 ndr_print_string(ndr, "help_file", r->help_file);
7965         }
7966         ndr->depth--;
7967         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7968         ndr->depth++;
7969         if (r->dependent_files) {
7970                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7971         }
7972         ndr->depth--;
7973         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7974         ndr->depth++;
7975         if (r->monitor_name) {
7976                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7977         }
7978         ndr->depth--;
7979         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7980         ndr->depth++;
7981         if (r->default_datatype) {
7982                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7983         }
7984         ndr->depth--;
7985         ndr->depth--;
7986 }
7987
7988 static enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
7989 {
7990         if (ndr_flags & NDR_SCALARS) {
7991                 NDR_CHECK(ndr_push_align(ndr, 4));
7992                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
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->driver_name));
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->architecture));
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->driver_path));
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->data_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->config_file));
8021                         ndr->flags = _flags_save_string;
8022                 }
8023                 {
8024                         uint32_t _flags_save_string = ndr->flags;
8025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8026                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8027                         ndr->flags = _flags_save_string;
8028                 }
8029                 {
8030                         uint32_t _flags_save_string_array = ndr->flags;
8031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8032                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8033                         ndr->flags = _flags_save_string_array;
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->monitor_name));
8039                         ndr->flags = _flags_save_string;
8040                 }
8041                 {
8042                         uint32_t _flags_save_string = ndr->flags;
8043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8045                         ndr->flags = _flags_save_string;
8046                 }
8047                 {
8048                         uint32_t _flags_save_string_array = ndr->flags;
8049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8051                         ndr->flags = _flags_save_string_array;
8052                 }
8053         }
8054         if (ndr_flags & NDR_BUFFERS) {
8055                 {
8056                         uint32_t _flags_save_string = ndr->flags;
8057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8058                         if (r->driver_name) {
8059                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8060                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8061                         }
8062                         ndr->flags = _flags_save_string;
8063                 }
8064                 {
8065                         uint32_t _flags_save_string = ndr->flags;
8066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8067                         if (r->architecture) {
8068                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8069                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8070                         }
8071                         ndr->flags = _flags_save_string;
8072                 }
8073                 {
8074                         uint32_t _flags_save_string = ndr->flags;
8075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8076                         if (r->driver_path) {
8077                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8078                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8079                         }
8080                         ndr->flags = _flags_save_string;
8081                 }
8082                 {
8083                         uint32_t _flags_save_string = ndr->flags;
8084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8085                         if (r->data_file) {
8086                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8087                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8088                         }
8089                         ndr->flags = _flags_save_string;
8090                 }
8091                 {
8092                         uint32_t _flags_save_string = ndr->flags;
8093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8094                         if (r->config_file) {
8095                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8096                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8097                         }
8098                         ndr->flags = _flags_save_string;
8099                 }
8100                 {
8101                         uint32_t _flags_save_string = ndr->flags;
8102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8103                         if (r->help_file) {
8104                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8105                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8106                         }
8107                         ndr->flags = _flags_save_string;
8108                 }
8109                 {
8110                         uint32_t _flags_save_string_array = ndr->flags;
8111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8112                         if (r->dependent_files) {
8113                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8114                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8115                         }
8116                         ndr->flags = _flags_save_string_array;
8117                 }
8118                 {
8119                         uint32_t _flags_save_string = ndr->flags;
8120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8121                         if (r->monitor_name) {
8122                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8123                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8124                         }
8125                         ndr->flags = _flags_save_string;
8126                 }
8127                 {
8128                         uint32_t _flags_save_string = ndr->flags;
8129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8130                         if (r->default_datatype) {
8131                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8132                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8133                         }
8134                         ndr->flags = _flags_save_string;
8135                 }
8136                 {
8137                         uint32_t _flags_save_string_array = ndr->flags;
8138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8139                         if (r->previous_names) {
8140                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8141                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8142                         }
8143                         ndr->flags = _flags_save_string_array;
8144                 }
8145         }
8146         return NDR_ERR_SUCCESS;
8147 }
8148
8149 static enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
8150 {
8151         uint32_t _ptr_driver_name;
8152         TALLOC_CTX *_mem_save_driver_name_0;
8153         uint32_t _ptr_architecture;
8154         TALLOC_CTX *_mem_save_architecture_0;
8155         uint32_t _ptr_driver_path;
8156         TALLOC_CTX *_mem_save_driver_path_0;
8157         uint32_t _ptr_data_file;
8158         TALLOC_CTX *_mem_save_data_file_0;
8159         uint32_t _ptr_config_file;
8160         TALLOC_CTX *_mem_save_config_file_0;
8161         uint32_t _ptr_help_file;
8162         TALLOC_CTX *_mem_save_help_file_0;
8163         uint32_t _ptr_dependent_files;
8164         TALLOC_CTX *_mem_save_dependent_files_0;
8165         uint32_t _ptr_monitor_name;
8166         TALLOC_CTX *_mem_save_monitor_name_0;
8167         uint32_t _ptr_default_datatype;
8168         TALLOC_CTX *_mem_save_default_datatype_0;
8169         uint32_t _ptr_previous_names;
8170         TALLOC_CTX *_mem_save_previous_names_0;
8171         if (ndr_flags & NDR_SCALARS) {
8172                 NDR_CHECK(ndr_pull_align(ndr, 4));
8173                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8174                 {
8175                         uint32_t _flags_save_string = ndr->flags;
8176                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8177                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8178                         if (_ptr_driver_name) {
8179                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8180                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8181                         } else {
8182                                 r->driver_name = NULL;
8183                         }
8184                         ndr->flags = _flags_save_string;
8185                 }
8186                 {
8187                         uint32_t _flags_save_string = ndr->flags;
8188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8189                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8190                         if (_ptr_architecture) {
8191                                 NDR_PULL_ALLOC(ndr, r->architecture);
8192                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8193                         } else {
8194                                 r->architecture = NULL;
8195                         }
8196                         ndr->flags = _flags_save_string;
8197                 }
8198                 {
8199                         uint32_t _flags_save_string = ndr->flags;
8200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8201                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8202                         if (_ptr_driver_path) {
8203                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8204                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8205                         } else {
8206                                 r->driver_path = NULL;
8207                         }
8208                         ndr->flags = _flags_save_string;
8209                 }
8210                 {
8211                         uint32_t _flags_save_string = ndr->flags;
8212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8213                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8214                         if (_ptr_data_file) {
8215                                 NDR_PULL_ALLOC(ndr, r->data_file);
8216                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8217                         } else {
8218                                 r->data_file = NULL;
8219                         }
8220                         ndr->flags = _flags_save_string;
8221                 }
8222                 {
8223                         uint32_t _flags_save_string = ndr->flags;
8224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8225                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8226                         if (_ptr_config_file) {
8227                                 NDR_PULL_ALLOC(ndr, r->config_file);
8228                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8229                         } else {
8230                                 r->config_file = NULL;
8231                         }
8232                         ndr->flags = _flags_save_string;
8233                 }
8234                 {
8235                         uint32_t _flags_save_string = ndr->flags;
8236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8237                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8238                         if (_ptr_help_file) {
8239                                 NDR_PULL_ALLOC(ndr, r->help_file);
8240                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
8241                         } else {
8242                                 r->help_file = NULL;
8243                         }
8244                         ndr->flags = _flags_save_string;
8245                 }
8246                 {
8247                         uint32_t _flags_save_string_array = ndr->flags;
8248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8249                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8250                         if (_ptr_dependent_files) {
8251                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
8252                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
8253                         } else {
8254                                 r->dependent_files = NULL;
8255                         }
8256                         ndr->flags = _flags_save_string_array;
8257                 }
8258                 {
8259                         uint32_t _flags_save_string = ndr->flags;
8260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8261                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8262                         if (_ptr_monitor_name) {
8263                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
8264                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
8265                         } else {
8266                                 r->monitor_name = NULL;
8267                         }
8268                         ndr->flags = _flags_save_string;
8269                 }
8270                 {
8271                         uint32_t _flags_save_string = ndr->flags;
8272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8273                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8274                         if (_ptr_default_datatype) {
8275                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
8276                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
8277                         } else {
8278                                 r->default_datatype = NULL;
8279                         }
8280                         ndr->flags = _flags_save_string;
8281                 }
8282                 {
8283                         uint32_t _flags_save_string_array = ndr->flags;
8284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8285                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8286                         if (_ptr_previous_names) {
8287                                 NDR_PULL_ALLOC(ndr, r->previous_names);
8288                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
8289                         } else {
8290                                 r->previous_names = NULL;
8291                         }
8292                         ndr->flags = _flags_save_string_array;
8293                 }
8294         }
8295         if (ndr_flags & NDR_BUFFERS) {
8296                 {
8297                         uint32_t _flags_save_string = ndr->flags;
8298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8299                         if (r->driver_name) {
8300                                 uint32_t _relative_save_offset;
8301                                 _relative_save_offset = ndr->offset;
8302                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8303                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8304                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8305                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8306                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8307                                 ndr->offset = _relative_save_offset;
8308                         }
8309                         ndr->flags = _flags_save_string;
8310                 }
8311                 {
8312                         uint32_t _flags_save_string = ndr->flags;
8313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8314                         if (r->architecture) {
8315                                 uint32_t _relative_save_offset;
8316                                 _relative_save_offset = ndr->offset;
8317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8318                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8319                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8322                                 ndr->offset = _relative_save_offset;
8323                         }
8324                         ndr->flags = _flags_save_string;
8325                 }
8326                 {
8327                         uint32_t _flags_save_string = ndr->flags;
8328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8329                         if (r->driver_path) {
8330                                 uint32_t _relative_save_offset;
8331                                 _relative_save_offset = ndr->offset;
8332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8333                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8334                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8337                                 ndr->offset = _relative_save_offset;
8338                         }
8339                         ndr->flags = _flags_save_string;
8340                 }
8341                 {
8342                         uint32_t _flags_save_string = ndr->flags;
8343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8344                         if (r->data_file) {
8345                                 uint32_t _relative_save_offset;
8346                                 _relative_save_offset = ndr->offset;
8347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8348                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8349                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8352                                 ndr->offset = _relative_save_offset;
8353                         }
8354                         ndr->flags = _flags_save_string;
8355                 }
8356                 {
8357                         uint32_t _flags_save_string = ndr->flags;
8358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8359                         if (r->config_file) {
8360                                 uint32_t _relative_save_offset;
8361                                 _relative_save_offset = ndr->offset;
8362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8363                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8364                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8367                                 ndr->offset = _relative_save_offset;
8368                         }
8369                         ndr->flags = _flags_save_string;
8370                 }
8371                 {
8372                         uint32_t _flags_save_string = ndr->flags;
8373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8374                         if (r->help_file) {
8375                                 uint32_t _relative_save_offset;
8376                                 _relative_save_offset = ndr->offset;
8377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
8378                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8379                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
8381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8382                                 ndr->offset = _relative_save_offset;
8383                         }
8384                         ndr->flags = _flags_save_string;
8385                 }
8386                 {
8387                         uint32_t _flags_save_string_array = ndr->flags;
8388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8389                         if (r->dependent_files) {
8390                                 uint32_t _relative_save_offset;
8391                                 _relative_save_offset = ndr->offset;
8392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
8393                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8394                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8395                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
8396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8397                                 ndr->offset = _relative_save_offset;
8398                         }
8399                         ndr->flags = _flags_save_string_array;
8400                 }
8401                 {
8402                         uint32_t _flags_save_string = ndr->flags;
8403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8404                         if (r->monitor_name) {
8405                                 uint32_t _relative_save_offset;
8406                                 _relative_save_offset = ndr->offset;
8407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
8408                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8409                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8410                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
8411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8412                                 ndr->offset = _relative_save_offset;
8413                         }
8414                         ndr->flags = _flags_save_string;
8415                 }
8416                 {
8417                         uint32_t _flags_save_string = ndr->flags;
8418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8419                         if (r->default_datatype) {
8420                                 uint32_t _relative_save_offset;
8421                                 _relative_save_offset = ndr->offset;
8422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
8423                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8424                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
8426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8427                                 ndr->offset = _relative_save_offset;
8428                         }
8429                         ndr->flags = _flags_save_string;
8430                 }
8431                 {
8432                         uint32_t _flags_save_string_array = ndr->flags;
8433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8434                         if (r->previous_names) {
8435                                 uint32_t _relative_save_offset;
8436                                 _relative_save_offset = ndr->offset;
8437                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
8438                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8439                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8440                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
8441                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8442                                 ndr->offset = _relative_save_offset;
8443                         }
8444                         ndr->flags = _flags_save_string_array;
8445                 }
8446         }
8447         return NDR_ERR_SUCCESS;
8448 }
8449
8450 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
8451 {
8452         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
8453         ndr->depth++;
8454         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8455         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8456         ndr->depth++;
8457         if (r->driver_name) {
8458                 ndr_print_string(ndr, "driver_name", r->driver_name);
8459         }
8460         ndr->depth--;
8461         ndr_print_ptr(ndr, "architecture", r->architecture);
8462         ndr->depth++;
8463         if (r->architecture) {
8464                 ndr_print_string(ndr, "architecture", r->architecture);
8465         }
8466         ndr->depth--;
8467         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8468         ndr->depth++;
8469         if (r->driver_path) {
8470                 ndr_print_string(ndr, "driver_path", r->driver_path);
8471         }
8472         ndr->depth--;
8473         ndr_print_ptr(ndr, "data_file", r->data_file);
8474         ndr->depth++;
8475         if (r->data_file) {
8476                 ndr_print_string(ndr, "data_file", r->data_file);
8477         }
8478         ndr->depth--;
8479         ndr_print_ptr(ndr, "config_file", r->config_file);
8480         ndr->depth++;
8481         if (r->config_file) {
8482                 ndr_print_string(ndr, "config_file", r->config_file);
8483         }
8484         ndr->depth--;
8485         ndr_print_ptr(ndr, "help_file", r->help_file);
8486         ndr->depth++;
8487         if (r->help_file) {
8488                 ndr_print_string(ndr, "help_file", r->help_file);
8489         }
8490         ndr->depth--;
8491         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8492         ndr->depth++;
8493         if (r->dependent_files) {
8494                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
8495         }
8496         ndr->depth--;
8497         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8498         ndr->depth++;
8499         if (r->monitor_name) {
8500                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8501         }
8502         ndr->depth--;
8503         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8504         ndr->depth++;
8505         if (r->default_datatype) {
8506                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8507         }
8508         ndr->depth--;
8509         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8510         ndr->depth++;
8511         if (r->previous_names) {
8512                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
8513         }
8514         ndr->depth--;
8515         ndr->depth--;
8516 }
8517
8518 static enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
8519 {
8520         if (ndr_flags & NDR_SCALARS) {
8521                 NDR_CHECK(ndr_push_align(ndr, 4));
8522                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8523                 {
8524                         uint32_t _flags_save_string = ndr->flags;
8525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8526                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8527                         ndr->flags = _flags_save_string;
8528                 }
8529                 {
8530                         uint32_t _flags_save_string = ndr->flags;
8531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8533                         ndr->flags = _flags_save_string;
8534                 }
8535                 {
8536                         uint32_t _flags_save_string = ndr->flags;
8537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8539                         ndr->flags = _flags_save_string;
8540                 }
8541                 {
8542                         uint32_t _flags_save_string = ndr->flags;
8543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8545                         ndr->flags = _flags_save_string;
8546                 }
8547                 {
8548                         uint32_t _flags_save_string = ndr->flags;
8549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8551                         ndr->flags = _flags_save_string;
8552                 }
8553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
8554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
8555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
8556         }
8557         if (ndr_flags & NDR_BUFFERS) {
8558                 {
8559                         uint32_t _flags_save_string = ndr->flags;
8560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8561                         if (r->driver_name) {
8562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8564                         }
8565                         ndr->flags = _flags_save_string;
8566                 }
8567                 {
8568                         uint32_t _flags_save_string = ndr->flags;
8569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8570                         if (r->architecture) {
8571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8573                         }
8574                         ndr->flags = _flags_save_string;
8575                 }
8576                 {
8577                         uint32_t _flags_save_string = ndr->flags;
8578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8579                         if (r->driver_path) {
8580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8582                         }
8583                         ndr->flags = _flags_save_string;
8584                 }
8585                 {
8586                         uint32_t _flags_save_string = ndr->flags;
8587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8588                         if (r->data_file) {
8589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8591                         }
8592                         ndr->flags = _flags_save_string;
8593                 }
8594                 {
8595                         uint32_t _flags_save_string = ndr->flags;
8596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8597                         if (r->config_file) {
8598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8600                         }
8601                         ndr->flags = _flags_save_string;
8602                 }
8603         }
8604         return NDR_ERR_SUCCESS;
8605 }
8606
8607 static enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
8608 {
8609         uint32_t _ptr_driver_name;
8610         TALLOC_CTX *_mem_save_driver_name_0;
8611         uint32_t _ptr_architecture;
8612         TALLOC_CTX *_mem_save_architecture_0;
8613         uint32_t _ptr_driver_path;
8614         TALLOC_CTX *_mem_save_driver_path_0;
8615         uint32_t _ptr_data_file;
8616         TALLOC_CTX *_mem_save_data_file_0;
8617         uint32_t _ptr_config_file;
8618         TALLOC_CTX *_mem_save_config_file_0;
8619         if (ndr_flags & NDR_SCALARS) {
8620                 NDR_CHECK(ndr_pull_align(ndr, 4));
8621                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8622                 {
8623                         uint32_t _flags_save_string = ndr->flags;
8624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8625                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8626                         if (_ptr_driver_name) {
8627                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8628                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8629                         } else {
8630                                 r->driver_name = NULL;
8631                         }
8632                         ndr->flags = _flags_save_string;
8633                 }
8634                 {
8635                         uint32_t _flags_save_string = ndr->flags;
8636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8637                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8638                         if (_ptr_architecture) {
8639                                 NDR_PULL_ALLOC(ndr, r->architecture);
8640                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8641                         } else {
8642                                 r->architecture = NULL;
8643                         }
8644                         ndr->flags = _flags_save_string;
8645                 }
8646                 {
8647                         uint32_t _flags_save_string = ndr->flags;
8648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8649                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8650                         if (_ptr_driver_path) {
8651                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8652                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8653                         } else {
8654                                 r->driver_path = NULL;
8655                         }
8656                         ndr->flags = _flags_save_string;
8657                 }
8658                 {
8659                         uint32_t _flags_save_string = ndr->flags;
8660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8661                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8662                         if (_ptr_data_file) {
8663                                 NDR_PULL_ALLOC(ndr, r->data_file);
8664                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8665                         } else {
8666                                 r->data_file = NULL;
8667                         }
8668                         ndr->flags = _flags_save_string;
8669                 }
8670                 {
8671                         uint32_t _flags_save_string = ndr->flags;
8672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8673                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8674                         if (_ptr_config_file) {
8675                                 NDR_PULL_ALLOC(ndr, r->config_file);
8676                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8677                         } else {
8678                                 r->config_file = NULL;
8679                         }
8680                         ndr->flags = _flags_save_string;
8681                 }
8682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
8683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
8684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
8685         }
8686         if (ndr_flags & NDR_BUFFERS) {
8687                 {
8688                         uint32_t _flags_save_string = ndr->flags;
8689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8690                         if (r->driver_name) {
8691                                 uint32_t _relative_save_offset;
8692                                 _relative_save_offset = ndr->offset;
8693                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8694                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8695                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8696                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8697                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8698                                 ndr->offset = _relative_save_offset;
8699                         }
8700                         ndr->flags = _flags_save_string;
8701                 }
8702                 {
8703                         uint32_t _flags_save_string = ndr->flags;
8704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8705                         if (r->architecture) {
8706                                 uint32_t _relative_save_offset;
8707                                 _relative_save_offset = ndr->offset;
8708                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8709                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8710                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8711                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8712                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8713                                 ndr->offset = _relative_save_offset;
8714                         }
8715                         ndr->flags = _flags_save_string;
8716                 }
8717                 {
8718                         uint32_t _flags_save_string = ndr->flags;
8719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8720                         if (r->driver_path) {
8721                                 uint32_t _relative_save_offset;
8722                                 _relative_save_offset = ndr->offset;
8723                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8724                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8725                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8726                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8727                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8728                                 ndr->offset = _relative_save_offset;
8729                         }
8730                         ndr->flags = _flags_save_string;
8731                 }
8732                 {
8733                         uint32_t _flags_save_string = ndr->flags;
8734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8735                         if (r->data_file) {
8736                                 uint32_t _relative_save_offset;
8737                                 _relative_save_offset = ndr->offset;
8738                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8739                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8740                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8741                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8742                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8743                                 ndr->offset = _relative_save_offset;
8744                         }
8745                         ndr->flags = _flags_save_string;
8746                 }
8747                 {
8748                         uint32_t _flags_save_string = ndr->flags;
8749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8750                         if (r->config_file) {
8751                                 uint32_t _relative_save_offset;
8752                                 _relative_save_offset = ndr->offset;
8753                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8754                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8755                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8756                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8757                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8758                                 ndr->offset = _relative_save_offset;
8759                         }
8760                         ndr->flags = _flags_save_string;
8761                 }
8762         }
8763         return NDR_ERR_SUCCESS;
8764 }
8765
8766 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
8767 {
8768         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
8769         ndr->depth++;
8770         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8771         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8772         ndr->depth++;
8773         if (r->driver_name) {
8774                 ndr_print_string(ndr, "driver_name", r->driver_name);
8775         }
8776         ndr->depth--;
8777         ndr_print_ptr(ndr, "architecture", r->architecture);
8778         ndr->depth++;
8779         if (r->architecture) {
8780                 ndr_print_string(ndr, "architecture", r->architecture);
8781         }
8782         ndr->depth--;
8783         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8784         ndr->depth++;
8785         if (r->driver_path) {
8786                 ndr_print_string(ndr, "driver_path", r->driver_path);
8787         }
8788         ndr->depth--;
8789         ndr_print_ptr(ndr, "data_file", r->data_file);
8790         ndr->depth++;
8791         if (r->data_file) {
8792                 ndr_print_string(ndr, "data_file", r->data_file);
8793         }
8794         ndr->depth--;
8795         ndr_print_ptr(ndr, "config_file", r->config_file);
8796         ndr->depth++;
8797         if (r->config_file) {
8798                 ndr_print_string(ndr, "config_file", r->config_file);
8799         }
8800         ndr->depth--;
8801         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
8802         ndr_print_uint32(ndr, "config_version", r->config_version);
8803         ndr_print_uint32(ndr, "driver_version", r->driver_version);
8804         ndr->depth--;
8805 }
8806
8807 static enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
8808 {
8809         if (ndr_flags & NDR_SCALARS) {
8810                 NDR_CHECK(ndr_push_align(ndr, 8));
8811                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8812                 {
8813                         uint32_t _flags_save_string = ndr->flags;
8814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8815                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8816                         ndr->flags = _flags_save_string;
8817                 }
8818                 {
8819                         uint32_t _flags_save_string = ndr->flags;
8820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8821                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8822                         ndr->flags = _flags_save_string;
8823                 }
8824                 {
8825                         uint32_t _flags_save_string = ndr->flags;
8826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8827                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8828                         ndr->flags = _flags_save_string;
8829                 }
8830                 {
8831                         uint32_t _flags_save_string = ndr->flags;
8832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8833                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8834                         ndr->flags = _flags_save_string;
8835                 }
8836                 {
8837                         uint32_t _flags_save_string = ndr->flags;
8838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8839                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8840                         ndr->flags = _flags_save_string;
8841                 }
8842                 {
8843                         uint32_t _flags_save_string = ndr->flags;
8844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8845                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8846                         ndr->flags = _flags_save_string;
8847                 }
8848                 {
8849                         uint32_t _flags_save_string_array = ndr->flags;
8850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8851                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8852                         ndr->flags = _flags_save_string_array;
8853                 }
8854                 {
8855                         uint32_t _flags_save_string = ndr->flags;
8856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8857                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8858                         ndr->flags = _flags_save_string;
8859                 }
8860                 {
8861                         uint32_t _flags_save_string = ndr->flags;
8862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8864                         ndr->flags = _flags_save_string;
8865                 }
8866                 {
8867                         uint32_t _flags_save_string_array = ndr->flags;
8868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8870                         ndr->flags = _flags_save_string_array;
8871                 }
8872                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
8873                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8874                 {
8875                         uint32_t _flags_save_string = ndr->flags;
8876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8877                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
8878                         ndr->flags = _flags_save_string;
8879                 }
8880                 {
8881                         uint32_t _flags_save_string = ndr->flags;
8882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8883                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
8884                         ndr->flags = _flags_save_string;
8885                 }
8886                 {
8887                         uint32_t _flags_save_string = ndr->flags;
8888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8889                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
8890                         ndr->flags = _flags_save_string;
8891                 }
8892                 {
8893                         uint32_t _flags_save_string = ndr->flags;
8894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8895                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
8896                         ndr->flags = _flags_save_string;
8897                 }
8898         }
8899         if (ndr_flags & NDR_BUFFERS) {
8900                 {
8901                         uint32_t _flags_save_string = ndr->flags;
8902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8903                         if (r->driver_name) {
8904                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8905                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8906                         }
8907                         ndr->flags = _flags_save_string;
8908                 }
8909                 {
8910                         uint32_t _flags_save_string = ndr->flags;
8911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8912                         if (r->architecture) {
8913                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8914                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8915                         }
8916                         ndr->flags = _flags_save_string;
8917                 }
8918                 {
8919                         uint32_t _flags_save_string = ndr->flags;
8920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8921                         if (r->driver_path) {
8922                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8923                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8924                         }
8925                         ndr->flags = _flags_save_string;
8926                 }
8927                 {
8928                         uint32_t _flags_save_string = ndr->flags;
8929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8930                         if (r->data_file) {
8931                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8932                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8933                         }
8934                         ndr->flags = _flags_save_string;
8935                 }
8936                 {
8937                         uint32_t _flags_save_string = ndr->flags;
8938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8939                         if (r->config_file) {
8940                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8941                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8942                         }
8943                         ndr->flags = _flags_save_string;
8944                 }
8945                 {
8946                         uint32_t _flags_save_string = ndr->flags;
8947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8948                         if (r->help_file) {
8949                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8950                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8951                         }
8952                         ndr->flags = _flags_save_string;
8953                 }
8954                 {
8955                         uint32_t _flags_save_string_array = ndr->flags;
8956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8957                         if (r->dependent_files) {
8958                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8959                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8960                         }
8961                         ndr->flags = _flags_save_string_array;
8962                 }
8963                 {
8964                         uint32_t _flags_save_string = ndr->flags;
8965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8966                         if (r->monitor_name) {
8967                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8968                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8969                         }
8970                         ndr->flags = _flags_save_string;
8971                 }
8972                 {
8973                         uint32_t _flags_save_string = ndr->flags;
8974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8975                         if (r->default_datatype) {
8976                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8977                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8978                         }
8979                         ndr->flags = _flags_save_string;
8980                 }
8981                 {
8982                         uint32_t _flags_save_string_array = ndr->flags;
8983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8984                         if (r->previous_names) {
8985                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8986                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8987                         }
8988                         ndr->flags = _flags_save_string_array;
8989                 }
8990                 {
8991                         uint32_t _flags_save_string = ndr->flags;
8992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8993                         if (r->manufacturer_name) {
8994                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
8995                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
8996                         }
8997                         ndr->flags = _flags_save_string;
8998                 }
8999                 {
9000                         uint32_t _flags_save_string = ndr->flags;
9001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9002                         if (r->manufacturer_url) {
9003                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9004                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9005                         }
9006                         ndr->flags = _flags_save_string;
9007                 }
9008                 {
9009                         uint32_t _flags_save_string = ndr->flags;
9010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9011                         if (r->hardware_id) {
9012                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9013                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9014                         }
9015                         ndr->flags = _flags_save_string;
9016                 }
9017                 {
9018                         uint32_t _flags_save_string = ndr->flags;
9019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9020                         if (r->provider) {
9021                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9022                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9023                         }
9024                         ndr->flags = _flags_save_string;
9025                 }
9026         }
9027         return NDR_ERR_SUCCESS;
9028 }
9029
9030 static enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
9031 {
9032         uint32_t _ptr_driver_name;
9033         TALLOC_CTX *_mem_save_driver_name_0;
9034         uint32_t _ptr_architecture;
9035         TALLOC_CTX *_mem_save_architecture_0;
9036         uint32_t _ptr_driver_path;
9037         TALLOC_CTX *_mem_save_driver_path_0;
9038         uint32_t _ptr_data_file;
9039         TALLOC_CTX *_mem_save_data_file_0;
9040         uint32_t _ptr_config_file;
9041         TALLOC_CTX *_mem_save_config_file_0;
9042         uint32_t _ptr_help_file;
9043         TALLOC_CTX *_mem_save_help_file_0;
9044         uint32_t _ptr_dependent_files;
9045         TALLOC_CTX *_mem_save_dependent_files_0;
9046         uint32_t _ptr_monitor_name;
9047         TALLOC_CTX *_mem_save_monitor_name_0;
9048         uint32_t _ptr_default_datatype;
9049         TALLOC_CTX *_mem_save_default_datatype_0;
9050         uint32_t _ptr_previous_names;
9051         TALLOC_CTX *_mem_save_previous_names_0;
9052         uint32_t _ptr_manufacturer_name;
9053         TALLOC_CTX *_mem_save_manufacturer_name_0;
9054         uint32_t _ptr_manufacturer_url;
9055         TALLOC_CTX *_mem_save_manufacturer_url_0;
9056         uint32_t _ptr_hardware_id;
9057         TALLOC_CTX *_mem_save_hardware_id_0;
9058         uint32_t _ptr_provider;
9059         TALLOC_CTX *_mem_save_provider_0;
9060         if (ndr_flags & NDR_SCALARS) {
9061                 NDR_CHECK(ndr_pull_align(ndr, 8));
9062                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9063                 {
9064                         uint32_t _flags_save_string = ndr->flags;
9065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9066                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9067                         if (_ptr_driver_name) {
9068                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9069                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9070                         } else {
9071                                 r->driver_name = NULL;
9072                         }
9073                         ndr->flags = _flags_save_string;
9074                 }
9075                 {
9076                         uint32_t _flags_save_string = ndr->flags;
9077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9078                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9079                         if (_ptr_architecture) {
9080                                 NDR_PULL_ALLOC(ndr, r->architecture);
9081                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9082                         } else {
9083                                 r->architecture = NULL;
9084                         }
9085                         ndr->flags = _flags_save_string;
9086                 }
9087                 {
9088                         uint32_t _flags_save_string = ndr->flags;
9089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9090                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9091                         if (_ptr_driver_path) {
9092                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9093                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9094                         } else {
9095                                 r->driver_path = NULL;
9096                         }
9097                         ndr->flags = _flags_save_string;
9098                 }
9099                 {
9100                         uint32_t _flags_save_string = ndr->flags;
9101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9102                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9103                         if (_ptr_data_file) {
9104                                 NDR_PULL_ALLOC(ndr, r->data_file);
9105                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9106                         } else {
9107                                 r->data_file = NULL;
9108                         }
9109                         ndr->flags = _flags_save_string;
9110                 }
9111                 {
9112                         uint32_t _flags_save_string = ndr->flags;
9113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9114                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9115                         if (_ptr_config_file) {
9116                                 NDR_PULL_ALLOC(ndr, r->config_file);
9117                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9118                         } else {
9119                                 r->config_file = NULL;
9120                         }
9121                         ndr->flags = _flags_save_string;
9122                 }
9123                 {
9124                         uint32_t _flags_save_string = ndr->flags;
9125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9126                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9127                         if (_ptr_help_file) {
9128                                 NDR_PULL_ALLOC(ndr, r->help_file);
9129                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9130                         } else {
9131                                 r->help_file = NULL;
9132                         }
9133                         ndr->flags = _flags_save_string;
9134                 }
9135                 {
9136                         uint32_t _flags_save_string_array = ndr->flags;
9137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9138                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9139                         if (_ptr_dependent_files) {
9140                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9141                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9142                         } else {
9143                                 r->dependent_files = NULL;
9144                         }
9145                         ndr->flags = _flags_save_string_array;
9146                 }
9147                 {
9148                         uint32_t _flags_save_string = ndr->flags;
9149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9150                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9151                         if (_ptr_monitor_name) {
9152                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9153                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9154                         } else {
9155                                 r->monitor_name = NULL;
9156                         }
9157                         ndr->flags = _flags_save_string;
9158                 }
9159                 {
9160                         uint32_t _flags_save_string = ndr->flags;
9161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9162                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9163                         if (_ptr_default_datatype) {
9164                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9165                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9166                         } else {
9167                                 r->default_datatype = NULL;
9168                         }
9169                         ndr->flags = _flags_save_string;
9170                 }
9171                 {
9172                         uint32_t _flags_save_string_array = ndr->flags;
9173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9174                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9175                         if (_ptr_previous_names) {
9176                                 NDR_PULL_ALLOC(ndr, r->previous_names);
9177                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
9178                         } else {
9179                                 r->previous_names = NULL;
9180                         }
9181                         ndr->flags = _flags_save_string_array;
9182                 }
9183                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
9184                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9185                 {
9186                         uint32_t _flags_save_string = ndr->flags;
9187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9188                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9189                         if (_ptr_manufacturer_name) {
9190                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9191                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
9192                         } else {
9193                                 r->manufacturer_name = NULL;
9194                         }
9195                         ndr->flags = _flags_save_string;
9196                 }
9197                 {
9198                         uint32_t _flags_save_string = ndr->flags;
9199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9200                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9201                         if (_ptr_manufacturer_url) {
9202                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9203                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
9204                         } else {
9205                                 r->manufacturer_url = NULL;
9206                         }
9207                         ndr->flags = _flags_save_string;
9208                 }
9209                 {
9210                         uint32_t _flags_save_string = ndr->flags;
9211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9212                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9213                         if (_ptr_hardware_id) {
9214                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
9215                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
9216                         } else {
9217                                 r->hardware_id = NULL;
9218                         }
9219                         ndr->flags = _flags_save_string;
9220                 }
9221                 {
9222                         uint32_t _flags_save_string = ndr->flags;
9223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9225                         if (_ptr_provider) {
9226                                 NDR_PULL_ALLOC(ndr, r->provider);
9227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
9228                         } else {
9229                                 r->provider = NULL;
9230                         }
9231                         ndr->flags = _flags_save_string;
9232                 }
9233         }
9234         if (ndr_flags & NDR_BUFFERS) {
9235                 {
9236                         uint32_t _flags_save_string = ndr->flags;
9237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9238                         if (r->driver_name) {
9239                                 uint32_t _relative_save_offset;
9240                                 _relative_save_offset = ndr->offset;
9241                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9242                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9243                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9244                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9245                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9246                                 ndr->offset = _relative_save_offset;
9247                         }
9248                         ndr->flags = _flags_save_string;
9249                 }
9250                 {
9251                         uint32_t _flags_save_string = ndr->flags;
9252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9253                         if (r->architecture) {
9254                                 uint32_t _relative_save_offset;
9255                                 _relative_save_offset = ndr->offset;
9256                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9257                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9258                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9259                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9260                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9261                                 ndr->offset = _relative_save_offset;
9262                         }
9263                         ndr->flags = _flags_save_string;
9264                 }
9265                 {
9266                         uint32_t _flags_save_string = ndr->flags;
9267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9268                         if (r->driver_path) {
9269                                 uint32_t _relative_save_offset;
9270                                 _relative_save_offset = ndr->offset;
9271                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9272                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9273                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9274                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9275                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9276                                 ndr->offset = _relative_save_offset;
9277                         }
9278                         ndr->flags = _flags_save_string;
9279                 }
9280                 {
9281                         uint32_t _flags_save_string = ndr->flags;
9282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9283                         if (r->data_file) {
9284                                 uint32_t _relative_save_offset;
9285                                 _relative_save_offset = ndr->offset;
9286                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9287                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9288                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9289                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9290                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9291                                 ndr->offset = _relative_save_offset;
9292                         }
9293                         ndr->flags = _flags_save_string;
9294                 }
9295                 {
9296                         uint32_t _flags_save_string = ndr->flags;
9297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9298                         if (r->config_file) {
9299                                 uint32_t _relative_save_offset;
9300                                 _relative_save_offset = ndr->offset;
9301                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9302                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9303                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9304                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9305                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9306                                 ndr->offset = _relative_save_offset;
9307                         }
9308                         ndr->flags = _flags_save_string;
9309                 }
9310                 {
9311                         uint32_t _flags_save_string = ndr->flags;
9312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9313                         if (r->help_file) {
9314                                 uint32_t _relative_save_offset;
9315                                 _relative_save_offset = ndr->offset;
9316                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9317                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9318                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9319                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9320                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9321                                 ndr->offset = _relative_save_offset;
9322                         }
9323                         ndr->flags = _flags_save_string;
9324                 }
9325                 {
9326                         uint32_t _flags_save_string_array = ndr->flags;
9327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9328                         if (r->dependent_files) {
9329                                 uint32_t _relative_save_offset;
9330                                 _relative_save_offset = ndr->offset;
9331                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9332                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9333                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9334                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9335                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9336                                 ndr->offset = _relative_save_offset;
9337                         }
9338                         ndr->flags = _flags_save_string_array;
9339                 }
9340                 {
9341                         uint32_t _flags_save_string = ndr->flags;
9342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9343                         if (r->monitor_name) {
9344                                 uint32_t _relative_save_offset;
9345                                 _relative_save_offset = ndr->offset;
9346                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9347                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9348                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9349                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9350                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9351                                 ndr->offset = _relative_save_offset;
9352                         }
9353                         ndr->flags = _flags_save_string;
9354                 }
9355                 {
9356                         uint32_t _flags_save_string = ndr->flags;
9357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9358                         if (r->default_datatype) {
9359                                 uint32_t _relative_save_offset;
9360                                 _relative_save_offset = ndr->offset;
9361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9362                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9363                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9366                                 ndr->offset = _relative_save_offset;
9367                         }
9368                         ndr->flags = _flags_save_string;
9369                 }
9370                 {
9371                         uint32_t _flags_save_string_array = ndr->flags;
9372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9373                         if (r->previous_names) {
9374                                 uint32_t _relative_save_offset;
9375                                 _relative_save_offset = ndr->offset;
9376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
9377                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9378                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9379                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
9380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9381                                 ndr->offset = _relative_save_offset;
9382                         }
9383                         ndr->flags = _flags_save_string_array;
9384                 }
9385                 {
9386                         uint32_t _flags_save_string = ndr->flags;
9387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9388                         if (r->manufacturer_name) {
9389                                 uint32_t _relative_save_offset;
9390                                 _relative_save_offset = ndr->offset;
9391                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
9392                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9393                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9394                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
9395                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9396                                 ndr->offset = _relative_save_offset;
9397                         }
9398                         ndr->flags = _flags_save_string;
9399                 }
9400                 {
9401                         uint32_t _flags_save_string = ndr->flags;
9402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9403                         if (r->manufacturer_url) {
9404                                 uint32_t _relative_save_offset;
9405                                 _relative_save_offset = ndr->offset;
9406                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
9407                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9408                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9409                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
9410                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9411                                 ndr->offset = _relative_save_offset;
9412                         }
9413                         ndr->flags = _flags_save_string;
9414                 }
9415                 {
9416                         uint32_t _flags_save_string = ndr->flags;
9417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9418                         if (r->hardware_id) {
9419                                 uint32_t _relative_save_offset;
9420                                 _relative_save_offset = ndr->offset;
9421                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
9422                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9423                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9424                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
9425                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9426                                 ndr->offset = _relative_save_offset;
9427                         }
9428                         ndr->flags = _flags_save_string;
9429                 }
9430                 {
9431                         uint32_t _flags_save_string = ndr->flags;
9432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9433                         if (r->provider) {
9434                                 uint32_t _relative_save_offset;
9435                                 _relative_save_offset = ndr->offset;
9436                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
9437                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9438                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9439                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
9440                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9441                                 ndr->offset = _relative_save_offset;
9442                         }
9443                         ndr->flags = _flags_save_string;
9444                 }
9445         }
9446         return NDR_ERR_SUCCESS;
9447 }
9448
9449 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
9450 {
9451         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
9452         ndr->depth++;
9453         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9454         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9455         ndr->depth++;
9456         if (r->driver_name) {
9457                 ndr_print_string(ndr, "driver_name", r->driver_name);
9458         }
9459         ndr->depth--;
9460         ndr_print_ptr(ndr, "architecture", r->architecture);
9461         ndr->depth++;
9462         if (r->architecture) {
9463                 ndr_print_string(ndr, "architecture", r->architecture);
9464         }
9465         ndr->depth--;
9466         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9467         ndr->depth++;
9468         if (r->driver_path) {
9469                 ndr_print_string(ndr, "driver_path", r->driver_path);
9470         }
9471         ndr->depth--;
9472         ndr_print_ptr(ndr, "data_file", r->data_file);
9473         ndr->depth++;
9474         if (r->data_file) {
9475                 ndr_print_string(ndr, "data_file", r->data_file);
9476         }
9477         ndr->depth--;
9478         ndr_print_ptr(ndr, "config_file", r->config_file);
9479         ndr->depth++;
9480         if (r->config_file) {
9481                 ndr_print_string(ndr, "config_file", r->config_file);
9482         }
9483         ndr->depth--;
9484         ndr_print_ptr(ndr, "help_file", r->help_file);
9485         ndr->depth++;
9486         if (r->help_file) {
9487                 ndr_print_string(ndr, "help_file", r->help_file);
9488         }
9489         ndr->depth--;
9490         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9491         ndr->depth++;
9492         if (r->dependent_files) {
9493                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9494         }
9495         ndr->depth--;
9496         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9497         ndr->depth++;
9498         if (r->monitor_name) {
9499                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9500         }
9501         ndr->depth--;
9502         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9503         ndr->depth++;
9504         if (r->default_datatype) {
9505                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9506         }
9507         ndr->depth--;
9508         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9509         ndr->depth++;
9510         if (r->previous_names) {
9511                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
9512         }
9513         ndr->depth--;
9514         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
9515         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9516         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9517         ndr->depth++;
9518         if (r->manufacturer_name) {
9519                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9520         }
9521         ndr->depth--;
9522         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9523         ndr->depth++;
9524         if (r->manufacturer_url) {
9525                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9526         }
9527         ndr->depth--;
9528         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9529         ndr->depth++;
9530         if (r->hardware_id) {
9531                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9532         }
9533         ndr->depth--;
9534         ndr_print_ptr(ndr, "provider", r->provider);
9535         ndr->depth++;
9536         if (r->provider) {
9537                 ndr_print_string(ndr, "provider", r->provider);
9538         }
9539         ndr->depth--;
9540         ndr->depth--;
9541 }
9542
9543 static enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
9544 {
9545         if (ndr_flags & NDR_SCALARS) {
9546                 NDR_CHECK(ndr_push_align(ndr, 8));
9547                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9548                 {
9549                         uint32_t _flags_save_string = ndr->flags;
9550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9551                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9552                         ndr->flags = _flags_save_string;
9553                 }
9554                 {
9555                         uint32_t _flags_save_string = ndr->flags;
9556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9557                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9558                         ndr->flags = _flags_save_string;
9559                 }
9560                 {
9561                         uint32_t _flags_save_string = ndr->flags;
9562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9563                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9564                         ndr->flags = _flags_save_string;
9565                 }
9566                 {
9567                         uint32_t _flags_save_string = ndr->flags;
9568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9570                         ndr->flags = _flags_save_string;
9571                 }
9572                 {
9573                         uint32_t _flags_save_string = ndr->flags;
9574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9576                         ndr->flags = _flags_save_string;
9577                 }
9578                 {
9579                         uint32_t _flags_save_string = ndr->flags;
9580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
9582                         ndr->flags = _flags_save_string;
9583                 }
9584                 {
9585                         uint32_t _flags_save_string = ndr->flags;
9586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
9588                         ndr->flags = _flags_save_string;
9589                 }
9590                 {
9591                         uint32_t _flags_save_string = ndr->flags;
9592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
9594                         ndr->flags = _flags_save_string;
9595                 }
9596                 {
9597                         uint32_t _flags_save_string_array = ndr->flags;
9598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
9600                         ndr->flags = _flags_save_string_array;
9601                 }
9602                 {
9603                         uint32_t _flags_save_string_array = ndr->flags;
9604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
9606                         ndr->flags = _flags_save_string_array;
9607                 }
9608                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
9609                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9610                 {
9611                         uint32_t _flags_save_string = ndr->flags;
9612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9613                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
9614                         ndr->flags = _flags_save_string;
9615                 }
9616                 {
9617                         uint32_t _flags_save_string = ndr->flags;
9618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9619                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
9620                         ndr->flags = _flags_save_string;
9621                 }
9622                 {
9623                         uint32_t _flags_save_string = ndr->flags;
9624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9625                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
9626                         ndr->flags = _flags_save_string;
9627                 }
9628                 {
9629                         uint32_t _flags_save_string = ndr->flags;
9630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9631                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
9632                         ndr->flags = _flags_save_string;
9633                 }
9634                 {
9635                         uint32_t _flags_save_string = ndr->flags;
9636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
9638                         ndr->flags = _flags_save_string;
9639                 }
9640                 {
9641                         uint32_t _flags_save_string = ndr->flags;
9642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9643                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
9644                         ndr->flags = _flags_save_string;
9645                 }
9646                 {
9647                         uint32_t _flags_save_string_array = ndr->flags;
9648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9649                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
9650                         ndr->flags = _flags_save_string_array;
9651                 }
9652                 {
9653                         uint32_t _flags_save_string = ndr->flags;
9654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9655                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
9656                         ndr->flags = _flags_save_string;
9657                 }
9658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9659                 {
9660                         uint32_t _flags_save_string_array = ndr->flags;
9661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9662                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
9663                         ndr->flags = _flags_save_string_array;
9664                 }
9665                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9666                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9667         }
9668         if (ndr_flags & NDR_BUFFERS) {
9669                 {
9670                         uint32_t _flags_save_string = ndr->flags;
9671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9672                         if (r->driver_name) {
9673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9675                         }
9676                         ndr->flags = _flags_save_string;
9677                 }
9678                 {
9679                         uint32_t _flags_save_string = ndr->flags;
9680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9681                         if (r->architecture) {
9682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
9691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
9700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
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->config_file) {
9709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_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->help_file) {
9718                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
9719                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_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->monitor_name) {
9727                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
9728                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
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->default_datatype) {
9736                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9737                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9738                         }
9739                         ndr->flags = _flags_save_string;
9740                 }
9741                 {
9742                         uint32_t _flags_save_string_array = ndr->flags;
9743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9744                         if (r->dependent_files) {
9745                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
9746                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
9747                         }
9748                         ndr->flags = _flags_save_string_array;
9749                 }
9750                 {
9751                         uint32_t _flags_save_string_array = ndr->flags;
9752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9753                         if (r->previous_names) {
9754                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9755                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9756                         }
9757                         ndr->flags = _flags_save_string_array;
9758                 }
9759                 {
9760                         uint32_t _flags_save_string = ndr->flags;
9761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9762                         if (r->manufacturer_name) {
9763                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9764                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9765                         }
9766                         ndr->flags = _flags_save_string;
9767                 }
9768                 {
9769                         uint32_t _flags_save_string = ndr->flags;
9770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9771                         if (r->manufacturer_url) {
9772                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9773                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
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->hardware_id) {
9781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
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->provider) {
9790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
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->print_processor) {
9799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
9800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
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->vendor_setup) {
9808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
9809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
9810                         }
9811                         ndr->flags = _flags_save_string;
9812                 }
9813                 {
9814                         uint32_t _flags_save_string_array = ndr->flags;
9815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9816                         if (r->color_profiles) {
9817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
9818                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
9819                         }
9820                         ndr->flags = _flags_save_string_array;
9821                 }
9822                 {
9823                         uint32_t _flags_save_string = ndr->flags;
9824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9825                         if (r->inf_path) {
9826                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
9827                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
9828                         }
9829                         ndr->flags = _flags_save_string;
9830                 }
9831                 {
9832                         uint32_t _flags_save_string_array = ndr->flags;
9833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9834                         if (r->core_driver_dependencies) {
9835                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
9836                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
9837                         }
9838                         ndr->flags = _flags_save_string_array;
9839                 }
9840         }
9841         return NDR_ERR_SUCCESS;
9842 }
9843
9844 static enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
9845 {
9846         uint32_t _ptr_driver_name;
9847         TALLOC_CTX *_mem_save_driver_name_0;
9848         uint32_t _ptr_architecture;
9849         TALLOC_CTX *_mem_save_architecture_0;
9850         uint32_t _ptr_driver_path;
9851         TALLOC_CTX *_mem_save_driver_path_0;
9852         uint32_t _ptr_data_file;
9853         TALLOC_CTX *_mem_save_data_file_0;
9854         uint32_t _ptr_config_file;
9855         TALLOC_CTX *_mem_save_config_file_0;
9856         uint32_t _ptr_help_file;
9857         TALLOC_CTX *_mem_save_help_file_0;
9858         uint32_t _ptr_monitor_name;
9859         TALLOC_CTX *_mem_save_monitor_name_0;
9860         uint32_t _ptr_default_datatype;
9861         TALLOC_CTX *_mem_save_default_datatype_0;
9862         uint32_t _ptr_dependent_files;
9863         TALLOC_CTX *_mem_save_dependent_files_0;
9864         uint32_t _ptr_previous_names;
9865         TALLOC_CTX *_mem_save_previous_names_0;
9866         uint32_t _ptr_manufacturer_name;
9867         TALLOC_CTX *_mem_save_manufacturer_name_0;
9868         uint32_t _ptr_manufacturer_url;
9869         TALLOC_CTX *_mem_save_manufacturer_url_0;
9870         uint32_t _ptr_hardware_id;
9871         TALLOC_CTX *_mem_save_hardware_id_0;
9872         uint32_t _ptr_provider;
9873         TALLOC_CTX *_mem_save_provider_0;
9874         uint32_t _ptr_print_processor;
9875         TALLOC_CTX *_mem_save_print_processor_0;
9876         uint32_t _ptr_vendor_setup;
9877         TALLOC_CTX *_mem_save_vendor_setup_0;
9878         uint32_t _ptr_color_profiles;
9879         TALLOC_CTX *_mem_save_color_profiles_0;
9880         uint32_t _ptr_inf_path;
9881         TALLOC_CTX *_mem_save_inf_path_0;
9882         uint32_t _ptr_core_driver_dependencies;
9883         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9884         if (ndr_flags & NDR_SCALARS) {
9885                 NDR_CHECK(ndr_pull_align(ndr, 8));
9886                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9887                 {
9888                         uint32_t _flags_save_string = ndr->flags;
9889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9891                         if (_ptr_driver_name) {
9892                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9894                         } else {
9895                                 r->driver_name = NULL;
9896                         }
9897                         ndr->flags = _flags_save_string;
9898                 }
9899                 {
9900                         uint32_t _flags_save_string = ndr->flags;
9901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9902                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9903                         if (_ptr_architecture) {
9904                                 NDR_PULL_ALLOC(ndr, r->architecture);
9905                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9906                         } else {
9907                                 r->architecture = NULL;
9908                         }
9909                         ndr->flags = _flags_save_string;
9910                 }
9911                 {
9912                         uint32_t _flags_save_string = ndr->flags;
9913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9914                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9915                         if (_ptr_driver_path) {
9916                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9917                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9918                         } else {
9919                                 r->driver_path = NULL;
9920                         }
9921                         ndr->flags = _flags_save_string;
9922                 }
9923                 {
9924                         uint32_t _flags_save_string = ndr->flags;
9925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9926                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9927                         if (_ptr_data_file) {
9928                                 NDR_PULL_ALLOC(ndr, r->data_file);
9929                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9930                         } else {
9931                                 r->data_file = NULL;
9932                         }
9933                         ndr->flags = _flags_save_string;
9934                 }
9935                 {
9936                         uint32_t _flags_save_string = ndr->flags;
9937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9938                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9939                         if (_ptr_config_file) {
9940                                 NDR_PULL_ALLOC(ndr, r->config_file);
9941                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9942                         } else {
9943                                 r->config_file = NULL;
9944                         }
9945                         ndr->flags = _flags_save_string;
9946                 }
9947                 {
9948                         uint32_t _flags_save_string = ndr->flags;
9949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9951                         if (_ptr_help_file) {
9952                                 NDR_PULL_ALLOC(ndr, r->help_file);
9953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9954                         } else {
9955                                 r->help_file = NULL;
9956                         }
9957                         ndr->flags = _flags_save_string;
9958                 }
9959                 {
9960                         uint32_t _flags_save_string = ndr->flags;
9961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9962                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9963                         if (_ptr_monitor_name) {
9964                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9965                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9966                         } else {
9967                                 r->monitor_name = NULL;
9968                         }
9969                         ndr->flags = _flags_save_string;
9970                 }
9971                 {
9972                         uint32_t _flags_save_string = ndr->flags;
9973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9974                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9975                         if (_ptr_default_datatype) {
9976                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9977                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9978                         } else {
9979                                 r->default_datatype = NULL;
9980                         }
9981                         ndr->flags = _flags_save_string;
9982                 }
9983                 {
9984                         uint32_t _flags_save_string_array = ndr->flags;
9985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9986                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9987                         if (_ptr_dependent_files) {
9988                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9989                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9990                         } else {
9991                                 r->dependent_files = NULL;
9992                         }
9993                         ndr->flags = _flags_save_string_array;
9994                 }
9995                 {
9996                         uint32_t _flags_save_string_array = ndr->flags;
9997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9998                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9999                         if (_ptr_previous_names) {
10000                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10001                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10002                         } else {
10003                                 r->previous_names = NULL;
10004                         }
10005                         ndr->flags = _flags_save_string_array;
10006                 }
10007                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
10008                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10009                 {
10010                         uint32_t _flags_save_string = ndr->flags;
10011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10012                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10013                         if (_ptr_manufacturer_name) {
10014                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10015                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
10016                         } else {
10017                                 r->manufacturer_name = NULL;
10018                         }
10019                         ndr->flags = _flags_save_string;
10020                 }
10021                 {
10022                         uint32_t _flags_save_string = ndr->flags;
10023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10025                         if (_ptr_manufacturer_url) {
10026                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
10028                         } else {
10029                                 r->manufacturer_url = NULL;
10030                         }
10031                         ndr->flags = _flags_save_string;
10032                 }
10033                 {
10034                         uint32_t _flags_save_string = ndr->flags;
10035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10036                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10037                         if (_ptr_hardware_id) {
10038                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
10039                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
10040                         } else {
10041                                 r->hardware_id = NULL;
10042                         }
10043                         ndr->flags = _flags_save_string;
10044                 }
10045                 {
10046                         uint32_t _flags_save_string = ndr->flags;
10047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10048                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10049                         if (_ptr_provider) {
10050                                 NDR_PULL_ALLOC(ndr, r->provider);
10051                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
10052                         } else {
10053                                 r->provider = NULL;
10054                         }
10055                         ndr->flags = _flags_save_string;
10056                 }
10057                 {
10058                         uint32_t _flags_save_string = ndr->flags;
10059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10060                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10061                         if (_ptr_print_processor) {
10062                                 NDR_PULL_ALLOC(ndr, r->print_processor);
10063                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
10064                         } else {
10065                                 r->print_processor = NULL;
10066                         }
10067                         ndr->flags = _flags_save_string;
10068                 }
10069                 {
10070                         uint32_t _flags_save_string = ndr->flags;
10071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10072                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10073                         if (_ptr_vendor_setup) {
10074                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
10075                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
10076                         } else {
10077                                 r->vendor_setup = NULL;
10078                         }
10079                         ndr->flags = _flags_save_string;
10080                 }
10081                 {
10082                         uint32_t _flags_save_string_array = ndr->flags;
10083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10084                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10085                         if (_ptr_color_profiles) {
10086                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
10087                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
10088                         } else {
10089                                 r->color_profiles = NULL;
10090                         }
10091                         ndr->flags = _flags_save_string_array;
10092                 }
10093                 {
10094                         uint32_t _flags_save_string = ndr->flags;
10095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10096                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10097                         if (_ptr_inf_path) {
10098                                 NDR_PULL_ALLOC(ndr, r->inf_path);
10099                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
10100                         } else {
10101                                 r->inf_path = NULL;
10102                         }
10103                         ndr->flags = _flags_save_string;
10104                 }
10105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10106                 {
10107                         uint32_t _flags_save_string_array = ndr->flags;
10108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10109                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10110                         if (_ptr_core_driver_dependencies) {
10111                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10112                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
10113                         } else {
10114                                 r->core_driver_dependencies = NULL;
10115                         }
10116                         ndr->flags = _flags_save_string_array;
10117                 }
10118                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10119                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10120         }
10121         if (ndr_flags & NDR_BUFFERS) {
10122                 {
10123                         uint32_t _flags_save_string = ndr->flags;
10124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10125                         if (r->driver_name) {
10126                                 uint32_t _relative_save_offset;
10127                                 _relative_save_offset = ndr->offset;
10128                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10129                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10130                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10131                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10132                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10133                                 ndr->offset = _relative_save_offset;
10134                         }
10135                         ndr->flags = _flags_save_string;
10136                 }
10137                 {
10138                         uint32_t _flags_save_string = ndr->flags;
10139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10140                         if (r->architecture) {
10141                                 uint32_t _relative_save_offset;
10142                                 _relative_save_offset = ndr->offset;
10143                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10144                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10145                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10146                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10147                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10148                                 ndr->offset = _relative_save_offset;
10149                         }
10150                         ndr->flags = _flags_save_string;
10151                 }
10152                 {
10153                         uint32_t _flags_save_string = ndr->flags;
10154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10155                         if (r->driver_path) {
10156                                 uint32_t _relative_save_offset;
10157                                 _relative_save_offset = ndr->offset;
10158                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10159                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10160                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10161                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10162                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10163                                 ndr->offset = _relative_save_offset;
10164                         }
10165                         ndr->flags = _flags_save_string;
10166                 }
10167                 {
10168                         uint32_t _flags_save_string = ndr->flags;
10169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10170                         if (r->data_file) {
10171                                 uint32_t _relative_save_offset;
10172                                 _relative_save_offset = ndr->offset;
10173                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10174                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10175                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10176                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10177                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10178                                 ndr->offset = _relative_save_offset;
10179                         }
10180                         ndr->flags = _flags_save_string;
10181                 }
10182                 {
10183                         uint32_t _flags_save_string = ndr->flags;
10184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10185                         if (r->config_file) {
10186                                 uint32_t _relative_save_offset;
10187                                 _relative_save_offset = ndr->offset;
10188                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10189                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10190                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10191                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10192                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10193                                 ndr->offset = _relative_save_offset;
10194                         }
10195                         ndr->flags = _flags_save_string;
10196                 }
10197                 {
10198                         uint32_t _flags_save_string = ndr->flags;
10199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10200                         if (r->help_file) {
10201                                 uint32_t _relative_save_offset;
10202                                 _relative_save_offset = ndr->offset;
10203                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10204                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10205                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10206                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10207                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10208                                 ndr->offset = _relative_save_offset;
10209                         }
10210                         ndr->flags = _flags_save_string;
10211                 }
10212                 {
10213                         uint32_t _flags_save_string = ndr->flags;
10214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10215                         if (r->monitor_name) {
10216                                 uint32_t _relative_save_offset;
10217                                 _relative_save_offset = ndr->offset;
10218                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10219                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10220                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10221                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10222                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10223                                 ndr->offset = _relative_save_offset;
10224                         }
10225                         ndr->flags = _flags_save_string;
10226                 }
10227                 {
10228                         uint32_t _flags_save_string = ndr->flags;
10229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10230                         if (r->default_datatype) {
10231                                 uint32_t _relative_save_offset;
10232                                 _relative_save_offset = ndr->offset;
10233                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10234                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10235                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10236                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10237                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10238                                 ndr->offset = _relative_save_offset;
10239                         }
10240                         ndr->flags = _flags_save_string;
10241                 }
10242                 {
10243                         uint32_t _flags_save_string_array = ndr->flags;
10244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10245                         if (r->dependent_files) {
10246                                 uint32_t _relative_save_offset;
10247                                 _relative_save_offset = ndr->offset;
10248                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10249                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10250                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10251                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10252                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10253                                 ndr->offset = _relative_save_offset;
10254                         }
10255                         ndr->flags = _flags_save_string_array;
10256                 }
10257                 {
10258                         uint32_t _flags_save_string_array = ndr->flags;
10259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10260                         if (r->previous_names) {
10261                                 uint32_t _relative_save_offset;
10262                                 _relative_save_offset = ndr->offset;
10263                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
10264                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10265                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10266                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
10267                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10268                                 ndr->offset = _relative_save_offset;
10269                         }
10270                         ndr->flags = _flags_save_string_array;
10271                 }
10272                 {
10273                         uint32_t _flags_save_string = ndr->flags;
10274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10275                         if (r->manufacturer_name) {
10276                                 uint32_t _relative_save_offset;
10277                                 _relative_save_offset = ndr->offset;
10278                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
10279                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10280                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10281                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
10282                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10283                                 ndr->offset = _relative_save_offset;
10284                         }
10285                         ndr->flags = _flags_save_string;
10286                 }
10287                 {
10288                         uint32_t _flags_save_string = ndr->flags;
10289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10290                         if (r->manufacturer_url) {
10291                                 uint32_t _relative_save_offset;
10292                                 _relative_save_offset = ndr->offset;
10293                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
10294                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10295                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10296                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
10297                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10298                                 ndr->offset = _relative_save_offset;
10299                         }
10300                         ndr->flags = _flags_save_string;
10301                 }
10302                 {
10303                         uint32_t _flags_save_string = ndr->flags;
10304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10305                         if (r->hardware_id) {
10306                                 uint32_t _relative_save_offset;
10307                                 _relative_save_offset = ndr->offset;
10308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
10309                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10310                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
10312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10313                                 ndr->offset = _relative_save_offset;
10314                         }
10315                         ndr->flags = _flags_save_string;
10316                 }
10317                 {
10318                         uint32_t _flags_save_string = ndr->flags;
10319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10320                         if (r->provider) {
10321                                 uint32_t _relative_save_offset;
10322                                 _relative_save_offset = ndr->offset;
10323                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
10324                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10325                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10326                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
10327                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10328                                 ndr->offset = _relative_save_offset;
10329                         }
10330                         ndr->flags = _flags_save_string;
10331                 }
10332                 {
10333                         uint32_t _flags_save_string = ndr->flags;
10334                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10335                         if (r->print_processor) {
10336                                 uint32_t _relative_save_offset;
10337                                 _relative_save_offset = ndr->offset;
10338                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
10339                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10340                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10341                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
10342                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10343                                 ndr->offset = _relative_save_offset;
10344                         }
10345                         ndr->flags = _flags_save_string;
10346                 }
10347                 {
10348                         uint32_t _flags_save_string = ndr->flags;
10349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10350                         if (r->vendor_setup) {
10351                                 uint32_t _relative_save_offset;
10352                                 _relative_save_offset = ndr->offset;
10353                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
10354                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10355                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10356                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
10357                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10358                                 ndr->offset = _relative_save_offset;
10359                         }
10360                         ndr->flags = _flags_save_string;
10361                 }
10362                 {
10363                         uint32_t _flags_save_string_array = ndr->flags;
10364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10365                         if (r->color_profiles) {
10366                                 uint32_t _relative_save_offset;
10367                                 _relative_save_offset = ndr->offset;
10368                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
10369                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10370                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10371                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
10372                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10373                                 ndr->offset = _relative_save_offset;
10374                         }
10375                         ndr->flags = _flags_save_string_array;
10376                 }
10377                 {
10378                         uint32_t _flags_save_string = ndr->flags;
10379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10380                         if (r->inf_path) {
10381                                 uint32_t _relative_save_offset;
10382                                 _relative_save_offset = ndr->offset;
10383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
10384                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10385                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
10387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10388                                 ndr->offset = _relative_save_offset;
10389                         }
10390                         ndr->flags = _flags_save_string;
10391                 }
10392                 {
10393                         uint32_t _flags_save_string_array = ndr->flags;
10394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10395                         if (r->core_driver_dependencies) {
10396                                 uint32_t _relative_save_offset;
10397                                 _relative_save_offset = ndr->offset;
10398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
10399                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10400                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10401                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
10402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10403                                 ndr->offset = _relative_save_offset;
10404                         }
10405                         ndr->flags = _flags_save_string_array;
10406                 }
10407         }
10408         return NDR_ERR_SUCCESS;
10409 }
10410
10411 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
10412 {
10413         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
10414         ndr->depth++;
10415         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10416         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10417         ndr->depth++;
10418         if (r->driver_name) {
10419                 ndr_print_string(ndr, "driver_name", r->driver_name);
10420         }
10421         ndr->depth--;
10422         ndr_print_ptr(ndr, "architecture", r->architecture);
10423         ndr->depth++;
10424         if (r->architecture) {
10425                 ndr_print_string(ndr, "architecture", r->architecture);
10426         }
10427         ndr->depth--;
10428         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10429         ndr->depth++;
10430         if (r->driver_path) {
10431                 ndr_print_string(ndr, "driver_path", r->driver_path);
10432         }
10433         ndr->depth--;
10434         ndr_print_ptr(ndr, "data_file", r->data_file);
10435         ndr->depth++;
10436         if (r->data_file) {
10437                 ndr_print_string(ndr, "data_file", r->data_file);
10438         }
10439         ndr->depth--;
10440         ndr_print_ptr(ndr, "config_file", r->config_file);
10441         ndr->depth++;
10442         if (r->config_file) {
10443                 ndr_print_string(ndr, "config_file", r->config_file);
10444         }
10445         ndr->depth--;
10446         ndr_print_ptr(ndr, "help_file", r->help_file);
10447         ndr->depth++;
10448         if (r->help_file) {
10449                 ndr_print_string(ndr, "help_file", r->help_file);
10450         }
10451         ndr->depth--;
10452         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10453         ndr->depth++;
10454         if (r->monitor_name) {
10455                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10456         }
10457         ndr->depth--;
10458         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10459         ndr->depth++;
10460         if (r->default_datatype) {
10461                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10462         }
10463         ndr->depth--;
10464         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10465         ndr->depth++;
10466         if (r->dependent_files) {
10467                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10468         }
10469         ndr->depth--;
10470         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10471         ndr->depth++;
10472         if (r->previous_names) {
10473                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10474         }
10475         ndr->depth--;
10476         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
10477         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10478         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10479         ndr->depth++;
10480         if (r->manufacturer_name) {
10481                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10482         }
10483         ndr->depth--;
10484         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10485         ndr->depth++;
10486         if (r->manufacturer_url) {
10487                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10488         }
10489         ndr->depth--;
10490         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10491         ndr->depth++;
10492         if (r->hardware_id) {
10493                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10494         }
10495         ndr->depth--;
10496         ndr_print_ptr(ndr, "provider", r->provider);
10497         ndr->depth++;
10498         if (r->provider) {
10499                 ndr_print_string(ndr, "provider", r->provider);
10500         }
10501         ndr->depth--;
10502         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10503         ndr->depth++;
10504         if (r->print_processor) {
10505                 ndr_print_string(ndr, "print_processor", r->print_processor);
10506         }
10507         ndr->depth--;
10508         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10509         ndr->depth++;
10510         if (r->vendor_setup) {
10511                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10512         }
10513         ndr->depth--;
10514         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10515         ndr->depth++;
10516         if (r->color_profiles) {
10517                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
10518         }
10519         ndr->depth--;
10520         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10521         ndr->depth++;
10522         if (r->inf_path) {
10523                 ndr_print_string(ndr, "inf_path", r->inf_path);
10524         }
10525         ndr->depth--;
10526         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10527         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10528         ndr->depth++;
10529         if (r->core_driver_dependencies) {
10530                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10531         }
10532         ndr->depth--;
10533         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10534         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10535         ndr->depth--;
10536 }
10537
10538 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
10539 {
10540         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10541         if (ndr_flags & NDR_SCALARS) {
10542                 int level = ndr_push_get_switch_value(ndr, r);
10543                 switch (level) {
10544                         case 1: {
10545                                 NDR_CHECK(ndr_push_align(ndr, 4));
10546                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10547                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10548                         break; }
10549
10550                         case 2: {
10551                                 NDR_CHECK(ndr_push_align(ndr, 4));
10552                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10553                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10554                         break; }
10555
10556                         case 3: {
10557                                 NDR_CHECK(ndr_push_align(ndr, 4));
10558                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10559                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10560                         break; }
10561
10562                         case 4: {
10563                                 NDR_CHECK(ndr_push_align(ndr, 4));
10564                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10565                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10566                         break; }
10567
10568                         case 5: {
10569                                 NDR_CHECK(ndr_push_align(ndr, 4));
10570                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10571                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10572                         break; }
10573
10574                         case 6: {
10575                                 NDR_CHECK(ndr_push_align(ndr, 8));
10576                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10577                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10578                         break; }
10579
10580                         case 8: {
10581                                 NDR_CHECK(ndr_push_align(ndr, 8));
10582                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10583                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10584                         break; }
10585
10586                         default: {
10587                         break; }
10588
10589                 }
10590         }
10591         if (ndr_flags & NDR_BUFFERS) {
10592                 int level = ndr_push_get_switch_value(ndr, r);
10593                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10594                 switch (level) {
10595                         case 1:
10596                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10597                         break;
10598
10599                         case 2:
10600                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10601                         break;
10602
10603                         case 3:
10604                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10605                         break;
10606
10607                         case 4:
10608                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10609                         break;
10610
10611                         case 5:
10612                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10613                         break;
10614
10615                         case 6:
10616                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10617                         break;
10618
10619                         case 8:
10620                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10621                         break;
10622
10623                         default:
10624                         break;
10625
10626                 }
10627         }
10628         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10629         return NDR_ERR_SUCCESS;
10630 }
10631
10632 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
10633 {
10634         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10635         int level;
10636         level = ndr_pull_get_switch_value(ndr, r);
10637         if (ndr_flags & NDR_SCALARS) {
10638                 switch (level) {
10639                         case 1: {
10640                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10641                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10642                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10643                         break; }
10644
10645                         case 2: {
10646                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10647                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10648                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10649                         break; }
10650
10651                         case 3: {
10652                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10653                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10654                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10655                         break; }
10656
10657                         case 4: {
10658                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10659                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10660                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10661                         break; }
10662
10663                         case 5: {
10664                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10665                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10666                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10667                         break; }
10668
10669                         case 6: {
10670                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10671                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10672                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10673                         break; }
10674
10675                         case 8: {
10676                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10677                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10678                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10679                         break; }
10680
10681                         default: {
10682                         break; }
10683
10684                 }
10685         }
10686         if (ndr_flags & NDR_BUFFERS) {
10687                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10688                 switch (level) {
10689                         case 1:
10690                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10691                         break;
10692
10693                         case 2:
10694                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10695                         break;
10696
10697                         case 3:
10698                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10699                         break;
10700
10701                         case 4:
10702                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10703                         break;
10704
10705                         case 5:
10706                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10707                         break;
10708
10709                         case 6:
10710                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10711                         break;
10712
10713                         case 8:
10714                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10715                         break;
10716
10717                         default:
10718                         break;
10719
10720                 }
10721         }
10722         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10723         return NDR_ERR_SUCCESS;
10724 }
10725
10726 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
10727 {
10728         int level;
10729         level = ndr_print_get_switch_value(ndr, r);
10730         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
10731         switch (level) {
10732                 case 1:
10733                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
10734                 break;
10735
10736                 case 2:
10737                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
10738                 break;
10739
10740                 case 3:
10741                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
10742                 break;
10743
10744                 case 4:
10745                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
10746                 break;
10747
10748                 case 5:
10749                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
10750                 break;
10751
10752                 case 6:
10753                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
10754                 break;
10755
10756                 case 8:
10757                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
10758                 break;
10759
10760                 default:
10761                 break;
10762
10763         }
10764 }
10765
10766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
10767 {
10768         if (ndr_flags & NDR_SCALARS) {
10769                 NDR_CHECK(ndr_push_align(ndr, 4));
10770                 {
10771                         uint32_t _flags_save_string = ndr->flags;
10772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10773                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
10774                         ndr->flags = _flags_save_string;
10775                 }
10776         }
10777         if (ndr_flags & NDR_BUFFERS) {
10778         }
10779         return NDR_ERR_SUCCESS;
10780 }
10781
10782 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
10783 {
10784         if (ndr_flags & NDR_SCALARS) {
10785                 NDR_CHECK(ndr_pull_align(ndr, 4));
10786                 {
10787                         uint32_t _flags_save_string = ndr->flags;
10788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10789                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
10790                         ndr->flags = _flags_save_string;
10791                 }
10792         }
10793         if (ndr_flags & NDR_BUFFERS) {
10794         }
10795         return NDR_ERR_SUCCESS;
10796 }
10797
10798 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
10799 {
10800         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
10801         ndr->depth++;
10802         ndr_print_string(ndr, "directory_name", r->directory_name);
10803         ndr->depth--;
10804 }
10805
10806 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10807 {
10808         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
10809 }
10810
10811 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
10812 {
10813         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10814         if (ndr_flags & NDR_SCALARS) {
10815                 int level = ndr_push_get_switch_value(ndr, r);
10816                 switch (level) {
10817                         case 1: {
10818                                 NDR_CHECK(ndr_push_align(ndr, 4));
10819                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10820                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10821                         break; }
10822
10823                         default: {
10824                                 NDR_CHECK(ndr_push_align(ndr, 4));
10825                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10826                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10827                         break; }
10828
10829                 }
10830         }
10831         if (ndr_flags & NDR_BUFFERS) {
10832                 int level = ndr_push_get_switch_value(ndr, r);
10833                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10834                 switch (level) {
10835                         case 1:
10836                         break;
10837
10838                         default:
10839                         break;
10840
10841                 }
10842         }
10843         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10844         return NDR_ERR_SUCCESS;
10845 }
10846
10847 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
10848 {
10849         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10850         int level;
10851         level = ndr_pull_get_switch_value(ndr, r);
10852         if (ndr_flags & NDR_SCALARS) {
10853                 switch (level) {
10854                         case 1: {
10855                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10856                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10857                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10858                         break; }
10859
10860                         default: {
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_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10864                         break; }
10865
10866                 }
10867         }
10868         if (ndr_flags & NDR_BUFFERS) {
10869                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10870                 switch (level) {
10871                         case 1:
10872                         break;
10873
10874                         default:
10875                         break;
10876
10877                 }
10878         }
10879         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10880         return NDR_ERR_SUCCESS;
10881 }
10882
10883 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
10884 {
10885         int level;
10886         level = ndr_print_get_switch_value(ndr, r);
10887         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
10888         switch (level) {
10889                 case 1:
10890                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10891                 break;
10892
10893                 default:
10894                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10895                 break;
10896
10897         }
10898 }
10899
10900 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
10901 {
10902         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
10903 }
10904
10905 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
10906 {
10907         if (ndr_flags & NDR_SCALARS) {
10908                 NDR_CHECK(ndr_push_align(ndr, 4));
10909                 {
10910                         uint32_t _flags_save_string = ndr->flags;
10911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10912                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
10913                         ndr->flags = _flags_save_string;
10914                 }
10915         }
10916         if (ndr_flags & NDR_BUFFERS) {
10917                 {
10918                         uint32_t _flags_save_string = ndr->flags;
10919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10920                         if (r->print_processor_name) {
10921                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
10922                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
10923                         }
10924                         ndr->flags = _flags_save_string;
10925                 }
10926         }
10927         return NDR_ERR_SUCCESS;
10928 }
10929
10930 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
10931 {
10932         uint32_t _ptr_print_processor_name;
10933         TALLOC_CTX *_mem_save_print_processor_name_0;
10934         if (ndr_flags & NDR_SCALARS) {
10935                 NDR_CHECK(ndr_pull_align(ndr, 4));
10936                 {
10937                         uint32_t _flags_save_string = ndr->flags;
10938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10939                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
10940                         if (_ptr_print_processor_name) {
10941                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
10942                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
10943                         } else {
10944                                 r->print_processor_name = NULL;
10945                         }
10946                         ndr->flags = _flags_save_string;
10947                 }
10948         }
10949         if (ndr_flags & NDR_BUFFERS) {
10950                 {
10951                         uint32_t _flags_save_string = ndr->flags;
10952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10953                         if (r->print_processor_name) {
10954                                 uint32_t _relative_save_offset;
10955                                 _relative_save_offset = ndr->offset;
10956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
10957                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10958                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
10959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
10960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
10961                                 ndr->offset = _relative_save_offset;
10962                         }
10963                         ndr->flags = _flags_save_string;
10964                 }
10965         }
10966         return NDR_ERR_SUCCESS;
10967 }
10968
10969 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
10970 {
10971         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
10972         ndr->depth++;
10973         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
10974         ndr->depth++;
10975         if (r->print_processor_name) {
10976                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
10977         }
10978         ndr->depth--;
10979         ndr->depth--;
10980 }
10981
10982 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
10983 {
10984         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10985         if (ndr_flags & NDR_SCALARS) {
10986                 int level = ndr_push_get_switch_value(ndr, r);
10987                 switch (level) {
10988                         case 1: {
10989                                 NDR_CHECK(ndr_push_align(ndr, 4));
10990                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10991                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
10992                         break; }
10993
10994                         default: {
10995                         break; }
10996
10997                 }
10998         }
10999         if (ndr_flags & NDR_BUFFERS) {
11000                 int level = ndr_push_get_switch_value(ndr, r);
11001                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11002                 switch (level) {
11003                         case 1:
11004                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11005                         break;
11006
11007                         default:
11008                         break;
11009
11010                 }
11011         }
11012         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11013         return NDR_ERR_SUCCESS;
11014 }
11015
11016 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
11017 {
11018         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11019         int level;
11020         level = ndr_pull_get_switch_value(ndr, r);
11021         if (ndr_flags & NDR_SCALARS) {
11022                 switch (level) {
11023                         case 1: {
11024                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11025                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11026                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11027                         break; }
11028
11029                         default: {
11030                         break; }
11031
11032                 }
11033         }
11034         if (ndr_flags & NDR_BUFFERS) {
11035                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11036                 switch (level) {
11037                         case 1:
11038                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11039                         break;
11040
11041                         default:
11042                         break;
11043
11044                 }
11045         }
11046         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11047         return NDR_ERR_SUCCESS;
11048 }
11049
11050 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
11051 {
11052         int level;
11053         level = ndr_print_get_switch_value(ndr, r);
11054         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
11055         switch (level) {
11056                 case 1:
11057                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
11058                 break;
11059
11060                 default:
11061                 break;
11062
11063         }
11064 }
11065
11066 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11067 {
11068         if (ndr_flags & NDR_SCALARS) {
11069                 NDR_CHECK(ndr_push_align(ndr, 4));
11070                 {
11071                         uint32_t _flags_save_string = ndr->flags;
11072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11073                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
11074                         ndr->flags = _flags_save_string;
11075                 }
11076         }
11077         if (ndr_flags & NDR_BUFFERS) {
11078         }
11079         return NDR_ERR_SUCCESS;
11080 }
11081
11082 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
11083 {
11084         if (ndr_flags & NDR_SCALARS) {
11085                 NDR_CHECK(ndr_pull_align(ndr, 4));
11086                 {
11087                         uint32_t _flags_save_string = ndr->flags;
11088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11089                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
11090                         ndr->flags = _flags_save_string;
11091                 }
11092         }
11093         if (ndr_flags & NDR_BUFFERS) {
11094         }
11095         return NDR_ERR_SUCCESS;
11096 }
11097
11098 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11099 {
11100         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
11101         ndr->depth++;
11102         ndr_print_string(ndr, "directory_name", r->directory_name);
11103         ndr->depth--;
11104 }
11105
11106 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
11107 {
11108         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
11109 }
11110
11111 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
11112 {
11113         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11114         if (ndr_flags & NDR_SCALARS) {
11115                 int level = ndr_push_get_switch_value(ndr, r);
11116                 switch (level) {
11117                         case 1: {
11118                                 NDR_CHECK(ndr_push_align(ndr, 4));
11119                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11120                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11121                         break; }
11122
11123                         default: {
11124                         break; }
11125
11126                 }
11127         }
11128         if (ndr_flags & NDR_BUFFERS) {
11129                 int level = ndr_push_get_switch_value(ndr, r);
11130                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11131                 switch (level) {
11132                         case 1:
11133                         break;
11134
11135                         default:
11136                         break;
11137
11138                 }
11139         }
11140         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11141         return NDR_ERR_SUCCESS;
11142 }
11143
11144 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
11145 {
11146         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11147         int level;
11148         level = ndr_pull_get_switch_value(ndr, r);
11149         if (ndr_flags & NDR_SCALARS) {
11150                 switch (level) {
11151                         case 1: {
11152                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11153                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11154                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11155                         break; }
11156
11157                         default: {
11158                         break; }
11159
11160                 }
11161         }
11162         if (ndr_flags & NDR_BUFFERS) {
11163                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11164                 switch (level) {
11165                         case 1:
11166                         break;
11167
11168                         default:
11169                         break;
11170
11171                 }
11172         }
11173         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11174         return NDR_ERR_SUCCESS;
11175 }
11176
11177 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
11178 {
11179         int level;
11180         level = ndr_print_get_switch_value(ndr, r);
11181         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
11182         switch (level) {
11183                 case 1:
11184                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
11185                 break;
11186
11187                 default:
11188                 break;
11189
11190         }
11191 }
11192
11193 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11194 {
11195         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
11196 }
11197
11198 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
11199 {
11200         if (ndr_flags & NDR_SCALARS) {
11201                 NDR_CHECK(ndr_push_align(ndr, 4));
11202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
11203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
11204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
11205         }
11206         if (ndr_flags & NDR_BUFFERS) {
11207                 if (r->document_name) {
11208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11212                 }
11213                 if (r->output_file) {
11214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11215                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11217                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11218                 }
11219                 if (r->datatype) {
11220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11221                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11223                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11224                 }
11225         }
11226         return NDR_ERR_SUCCESS;
11227 }
11228
11229 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
11230 {
11231         uint32_t _ptr_document_name;
11232         TALLOC_CTX *_mem_save_document_name_0;
11233         uint32_t _ptr_output_file;
11234         TALLOC_CTX *_mem_save_output_file_0;
11235         uint32_t _ptr_datatype;
11236         TALLOC_CTX *_mem_save_datatype_0;
11237         if (ndr_flags & NDR_SCALARS) {
11238                 NDR_CHECK(ndr_pull_align(ndr, 4));
11239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
11240                 if (_ptr_document_name) {
11241                         NDR_PULL_ALLOC(ndr, r->document_name);
11242                 } else {
11243                         r->document_name = NULL;
11244                 }
11245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
11246                 if (_ptr_output_file) {
11247                         NDR_PULL_ALLOC(ndr, r->output_file);
11248                 } else {
11249                         r->output_file = NULL;
11250                 }
11251                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
11252                 if (_ptr_datatype) {
11253                         NDR_PULL_ALLOC(ndr, r->datatype);
11254                 } else {
11255                         r->datatype = NULL;
11256                 }
11257         }
11258         if (ndr_flags & NDR_BUFFERS) {
11259                 if (r->document_name) {
11260                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11261                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
11262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
11263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
11264                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
11265                                 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));
11266                         }
11267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
11268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
11269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
11270                 }
11271                 if (r->output_file) {
11272                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11273                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
11274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
11275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
11276                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
11277                                 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));
11278                         }
11279                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
11280                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
11281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
11282                 }
11283                 if (r->datatype) {
11284                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11285                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
11286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
11287                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
11288                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
11289                                 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));
11290                         }
11291                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
11292                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
11293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
11294                 }
11295         }
11296         return NDR_ERR_SUCCESS;
11297 }
11298
11299 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
11300 {
11301         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
11302         ndr->depth++;
11303         ndr_print_ptr(ndr, "document_name", r->document_name);
11304         ndr->depth++;
11305         if (r->document_name) {
11306                 ndr_print_string(ndr, "document_name", r->document_name);
11307         }
11308         ndr->depth--;
11309         ndr_print_ptr(ndr, "output_file", r->output_file);
11310         ndr->depth++;
11311         if (r->output_file) {
11312                 ndr_print_string(ndr, "output_file", r->output_file);
11313         }
11314         ndr->depth--;
11315         ndr_print_ptr(ndr, "datatype", r->datatype);
11316         ndr->depth++;
11317         if (r->datatype) {
11318                 ndr_print_string(ndr, "datatype", r->datatype);
11319         }
11320         ndr->depth--;
11321         ndr->depth--;
11322 }
11323
11324 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
11325 {
11326         if (ndr_flags & NDR_SCALARS) {
11327                 int level = ndr_push_get_switch_value(ndr, r);
11328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11329                 switch (level) {
11330                         case 1: {
11331                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
11332                         break; }
11333
11334                         case 2: {
11335                         break; }
11336
11337                         case 3: {
11338                         break; }
11339
11340                         default: {
11341                         break; }
11342
11343                 }
11344         }
11345         if (ndr_flags & NDR_BUFFERS) {
11346                 int level = ndr_push_get_switch_value(ndr, r);
11347                 switch (level) {
11348                         case 1:
11349                                 if (r->info1) {
11350                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11351                                 }
11352                         break;
11353
11354                         case 2:
11355                         break;
11356
11357                         case 3:
11358                         break;
11359
11360                         default:
11361                         break;
11362
11363                 }
11364         }
11365         return NDR_ERR_SUCCESS;
11366 }
11367
11368 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
11369 {
11370         int level;
11371         uint32_t _level;
11372         TALLOC_CTX *_mem_save_info1_0;
11373         level = ndr_pull_get_switch_value(ndr, r);
11374         if (ndr_flags & NDR_SCALARS) {
11375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11376                 if (_level != level) {
11377                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11378                 }
11379                 switch (level) {
11380                         case 1: {
11381                                 uint32_t _ptr_info1;
11382                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
11383                                 if (_ptr_info1) {
11384                                         NDR_PULL_ALLOC(ndr, r->info1);
11385                                 } else {
11386                                         r->info1 = NULL;
11387                                 }
11388                         break; }
11389
11390                         case 2: {
11391                         break; }
11392
11393                         case 3: {
11394                         break; }
11395
11396                         default: {
11397                         break; }
11398
11399                 }
11400         }
11401         if (ndr_flags & NDR_BUFFERS) {
11402                 switch (level) {
11403                         case 1:
11404                                 if (r->info1) {
11405                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11406                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
11407                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11408                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
11409                                 }
11410                         break;
11411
11412                         case 2:
11413                         break;
11414
11415                         case 3:
11416                         break;
11417
11418                         default:
11419                         break;
11420
11421                 }
11422         }
11423         return NDR_ERR_SUCCESS;
11424 }
11425
11426 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
11427 {
11428         int level;
11429         level = ndr_print_get_switch_value(ndr, r);
11430         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
11431         switch (level) {
11432                 case 1:
11433                         ndr_print_ptr(ndr, "info1", r->info1);
11434                         ndr->depth++;
11435                         if (r->info1) {
11436                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
11437                         }
11438                         ndr->depth--;
11439                 break;
11440
11441                 case 2:
11442                 break;
11443
11444                 case 3:
11445                 break;
11446
11447                 default:
11448                 break;
11449
11450         }
11451 }
11452
11453 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
11454 {
11455         if (ndr_flags & NDR_SCALARS) {
11456                 NDR_CHECK(ndr_push_align(ndr, 4));
11457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
11458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11462                 {
11463                         uint32_t _flags_save_string = ndr->flags;
11464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11465                         {
11466                                 struct ndr_push *_ndr_extra_string;
11467                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11468                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11469                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11470                         }
11471                         ndr->flags = _flags_save_string;
11472                 }
11473         }
11474         if (ndr_flags & NDR_BUFFERS) {
11475         }
11476         return NDR_ERR_SUCCESS;
11477 }
11478
11479 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
11480 {
11481         if (ndr_flags & NDR_SCALARS) {
11482                 NDR_CHECK(ndr_pull_align(ndr, 4));
11483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
11488                 {
11489                         uint32_t _flags_save_string = ndr->flags;
11490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11491                         {
11492                                 struct ndr_pull *_ndr_extra_string;
11493                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11494                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11495                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11496                         }
11497                         ndr->flags = _flags_save_string;
11498                 }
11499         }
11500         if (ndr_flags & NDR_BUFFERS) {
11501         }
11502         return NDR_ERR_SUCCESS;
11503 }
11504
11505 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
11506 {
11507         ndr_print_struct(ndr, name, "spoolss_OSVersion");
11508         ndr->depth++;
11509         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);
11510         ndr_print_uint32(ndr, "major", r->major);
11511         ndr_print_uint32(ndr, "minor", r->minor);
11512         ndr_print_uint32(ndr, "build", r->build);
11513         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
11514         ndr_print_string(ndr, "extra_string", r->extra_string);
11515         ndr->depth--;
11516 }
11517
11518 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
11519 {
11520         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
11521 }
11522
11523 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
11524 {
11525         if (ndr_flags & NDR_SCALARS) {
11526                 NDR_CHECK(ndr_push_align(ndr, 4));
11527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
11528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11532                 {
11533                         uint32_t _flags_save_string = ndr->flags;
11534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11535                         {
11536                                 struct ndr_push *_ndr_extra_string;
11537                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11538                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11539                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11540                         }
11541                         ndr->flags = _flags_save_string;
11542                 }
11543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
11544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
11545         }
11546         if (ndr_flags & NDR_BUFFERS) {
11547         }
11548         return NDR_ERR_SUCCESS;
11549 }
11550
11551 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
11552 {
11553         if (ndr_flags & NDR_SCALARS) {
11554                 NDR_CHECK(ndr_pull_align(ndr, 4));
11555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
11560                 {
11561                         uint32_t _flags_save_string = ndr->flags;
11562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11563                         {
11564                                 struct ndr_pull *_ndr_extra_string;
11565                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11566                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11567                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11568                         }
11569                         ndr->flags = _flags_save_string;
11570                 }
11571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
11572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
11573         }
11574         if (ndr_flags & NDR_BUFFERS) {
11575         }
11576         return NDR_ERR_SUCCESS;
11577 }
11578
11579 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
11580 {
11581         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
11582         ndr->depth++;
11583         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);
11584         ndr_print_uint32(ndr, "major", r->major);
11585         ndr_print_uint32(ndr, "minor", r->minor);
11586         ndr_print_uint32(ndr, "build", r->build);
11587         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
11588         ndr_print_string(ndr, "extra_string", r->extra_string);
11589         ndr_print_uint32(ndr, "unknown2", r->unknown2);
11590         ndr_print_uint32(ndr, "unknown3", r->unknown3);
11591         ndr->depth--;
11592 }
11593
11594 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
11595 {
11596         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
11597 }
11598
11599 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
11600 {
11601         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11602         return NDR_ERR_SUCCESS;
11603 }
11604
11605 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
11606 {
11607         uint32_t v;
11608         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11609         *r = v;
11610         return NDR_ERR_SUCCESS;
11611 }
11612
11613 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
11614 {
11615         const char *val = NULL;
11616
11617         switch (r) {
11618                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
11619                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
11620                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
11621                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
11622                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
11623         }
11624         ndr_print_enum(ndr, name, "ENUM", val, r);
11625 }
11626
11627 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
11628 {
11629         if (ndr_flags & NDR_SCALARS) {
11630                 int level = ndr_push_get_switch_value(ndr, r);
11631                 switch (level) {
11632                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11633                         break; }
11634
11635                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11636                                 {
11637                                         uint32_t _flags_save_string = ndr->flags;
11638                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11639                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
11640                                         ndr->flags = _flags_save_string;
11641                                 }
11642                         break; }
11643
11644                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11645                                 {
11646                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11647                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11648                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11649                                         ndr->flags = _flags_save_DATA_BLOB;
11650                                 }
11651                         break; }
11652
11653                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11654                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
11655                         break; }
11656
11657                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11658                                 {
11659                                         uint32_t _flags_save_string_array = ndr->flags;
11660                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11661                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
11662                                         ndr->flags = _flags_save_string_array;
11663                                 }
11664                         break; }
11665
11666                         default: {
11667                                 {
11668                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11669                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11670                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
11671                                         ndr->flags = _flags_save_DATA_BLOB;
11672                                 }
11673                         break; }
11674
11675                 }
11676         }
11677         if (ndr_flags & NDR_BUFFERS) {
11678                 int level = ndr_push_get_switch_value(ndr, r);
11679                 switch (level) {
11680                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11681                         break;
11682
11683                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11684                         break;
11685
11686                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11687                         break;
11688
11689                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11690                         break;
11691
11692                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11693                         break;
11694
11695                         default:
11696                         break;
11697
11698                 }
11699         }
11700         return NDR_ERR_SUCCESS;
11701 }
11702
11703 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
11704 {
11705         int level;
11706         level = ndr_pull_get_switch_value(ndr, r);
11707         if (ndr_flags & NDR_SCALARS) {
11708                 switch (level) {
11709                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11710                         break; }
11711
11712                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11713                                 {
11714                                         uint32_t _flags_save_string = ndr->flags;
11715                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11716                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
11717                                         ndr->flags = _flags_save_string;
11718                                 }
11719                         break; }
11720
11721                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11722                                 {
11723                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11724                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11725                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
11726                                         ndr->flags = _flags_save_DATA_BLOB;
11727                                 }
11728                         break; }
11729
11730                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11731                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
11732                         break; }
11733
11734                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11735                                 {
11736                                         uint32_t _flags_save_string_array = ndr->flags;
11737                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11738                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
11739                                         ndr->flags = _flags_save_string_array;
11740                                 }
11741                         break; }
11742
11743                         default: {
11744                                 {
11745                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11746                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11747                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
11748                                         ndr->flags = _flags_save_DATA_BLOB;
11749                                 }
11750                         break; }
11751
11752                 }
11753         }
11754         if (ndr_flags & NDR_BUFFERS) {
11755                 switch (level) {
11756                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11757                         break;
11758
11759                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11760                         break;
11761
11762                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11763                         break;
11764
11765                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11766                         break;
11767
11768                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11769                         break;
11770
11771                         default:
11772                         break;
11773
11774                 }
11775         }
11776         return NDR_ERR_SUCCESS;
11777 }
11778
11779 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
11780 {
11781         int level;
11782         level = ndr_print_get_switch_value(ndr, r);
11783         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
11784         switch (level) {
11785                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11786                 break;
11787
11788                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11789                         ndr_print_string(ndr, "string", r->string);
11790                 break;
11791
11792                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11793                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
11794                 break;
11795
11796                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11797                         ndr_print_uint32(ndr, "value", r->value);
11798                 break;
11799
11800                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11801                         ndr_print_string_array(ndr, "string_array", r->string_array);
11802                 break;
11803
11804                 default:
11805                         ndr_print_DATA_BLOB(ndr, "data", r->data);
11806                 break;
11807
11808         }
11809 }
11810
11811 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11812 {
11813         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
11814 }
11815
11816 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
11817 {
11818         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11819         return NDR_ERR_SUCCESS;
11820 }
11821
11822 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
11823 {
11824         uint32_t v;
11825         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11826         *r = v;
11827         return NDR_ERR_SUCCESS;
11828 }
11829
11830 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
11831 {
11832         const char *val = NULL;
11833
11834         switch (r) {
11835                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
11836                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
11837                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
11838         }
11839         ndr_print_enum(ndr, name, "ENUM", val, r);
11840 }
11841
11842 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
11843 {
11844         if (ndr_flags & NDR_SCALARS) {
11845                 NDR_CHECK(ndr_push_align(ndr, 4));
11846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
11847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
11848         }
11849         if (ndr_flags & NDR_BUFFERS) {
11850         }
11851         return NDR_ERR_SUCCESS;
11852 }
11853
11854 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
11855 {
11856         if (ndr_flags & NDR_SCALARS) {
11857                 NDR_CHECK(ndr_pull_align(ndr, 4));
11858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
11859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
11860         }
11861         if (ndr_flags & NDR_BUFFERS) {
11862         }
11863         return NDR_ERR_SUCCESS;
11864 }
11865
11866 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
11867 {
11868         ndr_print_struct(ndr, name, "spoolss_FormSize");
11869         ndr->depth++;
11870         ndr_print_uint32(ndr, "width", r->width);
11871         ndr_print_uint32(ndr, "height", r->height);
11872         ndr->depth--;
11873 }
11874
11875 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
11876 {
11877         if (ndr_flags & NDR_SCALARS) {
11878                 NDR_CHECK(ndr_push_align(ndr, 4));
11879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
11880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
11881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
11882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
11883         }
11884         if (ndr_flags & NDR_BUFFERS) {
11885         }
11886         return NDR_ERR_SUCCESS;
11887 }
11888
11889 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
11890 {
11891         if (ndr_flags & NDR_SCALARS) {
11892                 NDR_CHECK(ndr_pull_align(ndr, 4));
11893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
11894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
11895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
11896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
11897         }
11898         if (ndr_flags & NDR_BUFFERS) {
11899         }
11900         return NDR_ERR_SUCCESS;
11901 }
11902
11903 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
11904 {
11905         ndr_print_struct(ndr, name, "spoolss_FormArea");
11906         ndr->depth++;
11907         ndr_print_uint32(ndr, "left", r->left);
11908         ndr_print_uint32(ndr, "top", r->top);
11909         ndr_print_uint32(ndr, "right", r->right);
11910         ndr_print_uint32(ndr, "bottom", r->bottom);
11911         ndr->depth--;
11912 }
11913
11914 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
11915 {
11916         if (ndr_flags & NDR_SCALARS) {
11917                 NDR_CHECK(ndr_push_align(ndr, 4));
11918                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
11919                 {
11920                         uint32_t _flags_save_string = ndr->flags;
11921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11922                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
11923                         ndr->flags = _flags_save_string;
11924                 }
11925                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11926                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11927         }
11928         if (ndr_flags & NDR_BUFFERS) {
11929                 {
11930                         uint32_t _flags_save_string = ndr->flags;
11931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11932                         if (r->form_name) {
11933                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
11934                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
11935                         }
11936                         ndr->flags = _flags_save_string;
11937                 }
11938         }
11939         return NDR_ERR_SUCCESS;
11940 }
11941
11942 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
11943 {
11944         uint32_t _ptr_form_name;
11945         TALLOC_CTX *_mem_save_form_name_0;
11946         if (ndr_flags & NDR_SCALARS) {
11947                 NDR_CHECK(ndr_pull_align(ndr, 4));
11948                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
11949                 {
11950                         uint32_t _flags_save_string = ndr->flags;
11951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11952                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
11953                         if (_ptr_form_name) {
11954                                 NDR_PULL_ALLOC(ndr, r->form_name);
11955                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
11956                         } else {
11957                                 r->form_name = NULL;
11958                         }
11959                         ndr->flags = _flags_save_string;
11960                 }
11961                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11962                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11963         }
11964         if (ndr_flags & NDR_BUFFERS) {
11965                 {
11966                         uint32_t _flags_save_string = ndr->flags;
11967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11968                         if (r->form_name) {
11969                                 uint32_t _relative_save_offset;
11970                                 _relative_save_offset = ndr->offset;
11971                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
11972                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11973                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
11974                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
11975                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
11976                                 ndr->offset = _relative_save_offset;
11977                         }
11978                         ndr->flags = _flags_save_string;
11979                 }
11980         }
11981         return NDR_ERR_SUCCESS;
11982 }
11983
11984 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
11985 {
11986         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
11987         ndr->depth++;
11988         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
11989         ndr_print_ptr(ndr, "form_name", r->form_name);
11990         ndr->depth++;
11991         if (r->form_name) {
11992                 ndr_print_string(ndr, "form_name", r->form_name);
11993         }
11994         ndr->depth--;
11995         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
11996         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
11997         ndr->depth--;
11998 }
11999
12000 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
12001 {
12002         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12003         if (ndr_flags & NDR_SCALARS) {
12004                 int level = ndr_push_get_switch_value(ndr, r);
12005                 switch (level) {
12006                         case 1: {
12007                                 NDR_CHECK(ndr_push_align(ndr, 4));
12008                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12009                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12010                         break; }
12011
12012                         default: {
12013                         break; }
12014
12015                 }
12016         }
12017         if (ndr_flags & NDR_BUFFERS) {
12018                 int level = ndr_push_get_switch_value(ndr, r);
12019                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12020                 switch (level) {
12021                         case 1:
12022                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12023                         break;
12024
12025                         default:
12026                         break;
12027
12028                 }
12029         }
12030         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12031         return NDR_ERR_SUCCESS;
12032 }
12033
12034 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
12035 {
12036         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12037         int level;
12038         level = ndr_pull_get_switch_value(ndr, r);
12039         if (ndr_flags & NDR_SCALARS) {
12040                 switch (level) {
12041                         case 1: {
12042                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12043                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12044                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12045                         break; }
12046
12047                         default: {
12048                         break; }
12049
12050                 }
12051         }
12052         if (ndr_flags & NDR_BUFFERS) {
12053                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12054                 switch (level) {
12055                         case 1:
12056                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12057                         break;
12058
12059                         default:
12060                         break;
12061
12062                 }
12063         }
12064         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12065         return NDR_ERR_SUCCESS;
12066 }
12067
12068 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
12069 {
12070         int level;
12071         level = ndr_print_get_switch_value(ndr, r);
12072         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
12073         switch (level) {
12074                 case 1:
12075                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
12076                 break;
12077
12078                 default:
12079                 break;
12080
12081         }
12082 }
12083
12084 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12085 {
12086         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
12087 }
12088
12089 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
12090 {
12091         if (ndr_flags & NDR_SCALARS) {
12092                 NDR_CHECK(ndr_push_align(ndr, 4));
12093                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
12094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
12095                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12096                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12097         }
12098         if (ndr_flags & NDR_BUFFERS) {
12099                 if (r->form_name) {
12100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12104                 }
12105         }
12106         return NDR_ERR_SUCCESS;
12107 }
12108
12109 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
12110 {
12111         uint32_t _ptr_form_name;
12112         TALLOC_CTX *_mem_save_form_name_0;
12113         if (ndr_flags & NDR_SCALARS) {
12114                 NDR_CHECK(ndr_pull_align(ndr, 4));
12115                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
12116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
12117                 if (_ptr_form_name) {
12118                         NDR_PULL_ALLOC(ndr, r->form_name);
12119                 } else {
12120                         r->form_name = NULL;
12121                 }
12122                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12123                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12124         }
12125         if (ndr_flags & NDR_BUFFERS) {
12126                 if (r->form_name) {
12127                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12128                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12129                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
12130                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
12131                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
12132                                 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));
12133                         }
12134                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
12135                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
12136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12137                 }
12138         }
12139         return NDR_ERR_SUCCESS;
12140 }
12141
12142 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
12143 {
12144         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
12145         ndr->depth++;
12146         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12147         ndr_print_ptr(ndr, "form_name", r->form_name);
12148         ndr->depth++;
12149         if (r->form_name) {
12150                 ndr_print_string(ndr, "form_name", r->form_name);
12151         }
12152         ndr->depth--;
12153         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12154         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12155         ndr->depth--;
12156 }
12157
12158 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
12159 {
12160         if (ndr_flags & NDR_SCALARS) {
12161                 int level = ndr_push_get_switch_value(ndr, r);
12162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12163                 switch (level) {
12164                         case 1: {
12165                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
12166                         break; }
12167
12168                         default:
12169                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12170                 }
12171         }
12172         if (ndr_flags & NDR_BUFFERS) {
12173                 int level = ndr_push_get_switch_value(ndr, r);
12174                 switch (level) {
12175                         case 1:
12176                                 if (r->info1) {
12177                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12178                                 }
12179                         break;
12180
12181                         default:
12182                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12183                 }
12184         }
12185         return NDR_ERR_SUCCESS;
12186 }
12187
12188 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
12189 {
12190         int level;
12191         uint32_t _level;
12192         TALLOC_CTX *_mem_save_info1_0;
12193         level = ndr_pull_get_switch_value(ndr, r);
12194         if (ndr_flags & NDR_SCALARS) {
12195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12196                 if (_level != level) {
12197                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12198                 }
12199                 switch (level) {
12200                         case 1: {
12201                                 uint32_t _ptr_info1;
12202                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
12203                                 if (_ptr_info1) {
12204                                         NDR_PULL_ALLOC(ndr, r->info1);
12205                                 } else {
12206                                         r->info1 = NULL;
12207                                 }
12208                         break; }
12209
12210                         default:
12211                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12212                 }
12213         }
12214         if (ndr_flags & NDR_BUFFERS) {
12215                 switch (level) {
12216                         case 1:
12217                                 if (r->info1) {
12218                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12219                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
12220                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12221                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
12222                                 }
12223                         break;
12224
12225                         default:
12226                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12227                 }
12228         }
12229         return NDR_ERR_SUCCESS;
12230 }
12231
12232 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
12233 {
12234         int level;
12235         level = ndr_print_get_switch_value(ndr, r);
12236         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
12237         switch (level) {
12238                 case 1:
12239                         ndr_print_ptr(ndr, "info1", r->info1);
12240                         ndr->depth++;
12241                         if (r->info1) {
12242                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
12243                         }
12244                         ndr->depth--;
12245                 break;
12246
12247                 default:
12248                         ndr_print_bad_level(ndr, name, level);
12249         }
12250 }
12251
12252 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
12253 {
12254         if (ndr_flags & NDR_SCALARS) {
12255                 NDR_CHECK(ndr_push_align(ndr, 4));
12256                 {
12257                         uint32_t _flags_save_string = ndr->flags;
12258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12260                         ndr->flags = _flags_save_string;
12261                 }
12262         }
12263         if (ndr_flags & NDR_BUFFERS) {
12264                 {
12265                         uint32_t _flags_save_string = ndr->flags;
12266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12267                         if (r->port_name) {
12268                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12269                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12270                         }
12271                         ndr->flags = _flags_save_string;
12272                 }
12273         }
12274         return NDR_ERR_SUCCESS;
12275 }
12276
12277 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
12278 {
12279         uint32_t _ptr_port_name;
12280         TALLOC_CTX *_mem_save_port_name_0;
12281         if (ndr_flags & NDR_SCALARS) {
12282                 NDR_CHECK(ndr_pull_align(ndr, 4));
12283                 {
12284                         uint32_t _flags_save_string = ndr->flags;
12285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12287                         if (_ptr_port_name) {
12288                                 NDR_PULL_ALLOC(ndr, r->port_name);
12289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12290                         } else {
12291                                 r->port_name = NULL;
12292                         }
12293                         ndr->flags = _flags_save_string;
12294                 }
12295         }
12296         if (ndr_flags & NDR_BUFFERS) {
12297                 {
12298                         uint32_t _flags_save_string = ndr->flags;
12299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12300                         if (r->port_name) {
12301                                 uint32_t _relative_save_offset;
12302                                 _relative_save_offset = ndr->offset;
12303                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12304                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12305                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12306                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12307                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12308                                 ndr->offset = _relative_save_offset;
12309                         }
12310                         ndr->flags = _flags_save_string;
12311                 }
12312         }
12313         return NDR_ERR_SUCCESS;
12314 }
12315
12316 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
12317 {
12318         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
12319         ndr->depth++;
12320         ndr_print_ptr(ndr, "port_name", r->port_name);
12321         ndr->depth++;
12322         if (r->port_name) {
12323                 ndr_print_string(ndr, "port_name", r->port_name);
12324         }
12325         ndr->depth--;
12326         ndr->depth--;
12327 }
12328
12329 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12330 {
12331         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12332         return NDR_ERR_SUCCESS;
12333 }
12334
12335 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12336 {
12337         uint32_t v;
12338         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12339         *r = v;
12340         return NDR_ERR_SUCCESS;
12341 }
12342
12343 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
12344 {
12345         ndr_print_uint32(ndr, name, r);
12346         ndr->depth++;
12347         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
12348         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
12349         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
12350         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
12351         ndr->depth--;
12352 }
12353
12354 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
12355 {
12356         if (ndr_flags & NDR_SCALARS) {
12357                 NDR_CHECK(ndr_push_align(ndr, 4));
12358                 {
12359                         uint32_t _flags_save_string = ndr->flags;
12360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12361                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12362                         ndr->flags = _flags_save_string;
12363                 }
12364                 {
12365                         uint32_t _flags_save_string = ndr->flags;
12366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12367                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12368                         ndr->flags = _flags_save_string;
12369                 }
12370                 {
12371                         uint32_t _flags_save_string = ndr->flags;
12372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12373                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
12374                         ndr->flags = _flags_save_string;
12375                 }
12376                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
12377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12378         }
12379         if (ndr_flags & NDR_BUFFERS) {
12380                 {
12381                         uint32_t _flags_save_string = ndr->flags;
12382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12383                         if (r->port_name) {
12384                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12385                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12386                         }
12387                         ndr->flags = _flags_save_string;
12388                 }
12389                 {
12390                         uint32_t _flags_save_string = ndr->flags;
12391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12392                         if (r->monitor_name) {
12393                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12394                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12395                         }
12396                         ndr->flags = _flags_save_string;
12397                 }
12398                 {
12399                         uint32_t _flags_save_string = ndr->flags;
12400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12401                         if (r->description) {
12402                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
12403                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
12404                         }
12405                         ndr->flags = _flags_save_string;
12406                 }
12407         }
12408         return NDR_ERR_SUCCESS;
12409 }
12410
12411 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
12412 {
12413         uint32_t _ptr_port_name;
12414         TALLOC_CTX *_mem_save_port_name_0;
12415         uint32_t _ptr_monitor_name;
12416         TALLOC_CTX *_mem_save_monitor_name_0;
12417         uint32_t _ptr_description;
12418         TALLOC_CTX *_mem_save_description_0;
12419         if (ndr_flags & NDR_SCALARS) {
12420                 NDR_CHECK(ndr_pull_align(ndr, 4));
12421                 {
12422                         uint32_t _flags_save_string = ndr->flags;
12423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12424                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12425                         if (_ptr_port_name) {
12426                                 NDR_PULL_ALLOC(ndr, r->port_name);
12427                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12428                         } else {
12429                                 r->port_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12437                         if (_ptr_monitor_name) {
12438                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12439                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12440                         } else {
12441                                 r->monitor_name = NULL;
12442                         }
12443                         ndr->flags = _flags_save_string;
12444                 }
12445                 {
12446                         uint32_t _flags_save_string = ndr->flags;
12447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12448                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
12449                         if (_ptr_description) {
12450                                 NDR_PULL_ALLOC(ndr, r->description);
12451                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
12452                         } else {
12453                                 r->description = NULL;
12454                         }
12455                         ndr->flags = _flags_save_string;
12456                 }
12457                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
12458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12459         }
12460         if (ndr_flags & NDR_BUFFERS) {
12461                 {
12462                         uint32_t _flags_save_string = ndr->flags;
12463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12464                         if (r->port_name) {
12465                                 uint32_t _relative_save_offset;
12466                                 _relative_save_offset = ndr->offset;
12467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12468                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12469                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12472                                 ndr->offset = _relative_save_offset;
12473                         }
12474                         ndr->flags = _flags_save_string;
12475                 }
12476                 {
12477                         uint32_t _flags_save_string = ndr->flags;
12478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12479                         if (r->monitor_name) {
12480                                 uint32_t _relative_save_offset;
12481                                 _relative_save_offset = ndr->offset;
12482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12483                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12484                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12487                                 ndr->offset = _relative_save_offset;
12488                         }
12489                         ndr->flags = _flags_save_string;
12490                 }
12491                 {
12492                         uint32_t _flags_save_string = ndr->flags;
12493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12494                         if (r->description) {
12495                                 uint32_t _relative_save_offset;
12496                                 _relative_save_offset = ndr->offset;
12497                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
12498                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
12499                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
12500                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
12501                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
12502                                 ndr->offset = _relative_save_offset;
12503                         }
12504                         ndr->flags = _flags_save_string;
12505                 }
12506         }
12507         return NDR_ERR_SUCCESS;
12508 }
12509
12510 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
12511 {
12512         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
12513         ndr->depth++;
12514         ndr_print_ptr(ndr, "port_name", r->port_name);
12515         ndr->depth++;
12516         if (r->port_name) {
12517                 ndr_print_string(ndr, "port_name", r->port_name);
12518         }
12519         ndr->depth--;
12520         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12521         ndr->depth++;
12522         if (r->monitor_name) {
12523                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12524         }
12525         ndr->depth--;
12526         ndr_print_ptr(ndr, "description", r->description);
12527         ndr->depth++;
12528         if (r->description) {
12529                 ndr_print_string(ndr, "description", r->description);
12530         }
12531         ndr->depth--;
12532         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
12533         ndr_print_uint32(ndr, "reserved", r->reserved);
12534         ndr->depth--;
12535 }
12536
12537 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
12538 {
12539         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12540         if (ndr_flags & NDR_SCALARS) {
12541                 int level = ndr_push_get_switch_value(ndr, r);
12542                 switch (level) {
12543                         case 1: {
12544                                 NDR_CHECK(ndr_push_align(ndr, 4));
12545                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12546                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12547                         break; }
12548
12549                         case 2: {
12550                                 NDR_CHECK(ndr_push_align(ndr, 4));
12551                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12552                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12553                         break; }
12554
12555                         case 3: {
12556                         break; }
12557
12558                         default: {
12559                         break; }
12560
12561                 }
12562         }
12563         if (ndr_flags & NDR_BUFFERS) {
12564                 int level = ndr_push_get_switch_value(ndr, r);
12565                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12566                 switch (level) {
12567                         case 1:
12568                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12569                         break;
12570
12571                         case 2:
12572                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12573                         break;
12574
12575                         case 3:
12576                         break;
12577
12578                         default:
12579                         break;
12580
12581                 }
12582         }
12583         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12584         return NDR_ERR_SUCCESS;
12585 }
12586
12587 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
12588 {
12589         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12590         int level;
12591         level = ndr_pull_get_switch_value(ndr, r);
12592         if (ndr_flags & NDR_SCALARS) {
12593                 switch (level) {
12594                         case 1: {
12595                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12596                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12597                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12598                         break; }
12599
12600                         case 2: {
12601                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12602                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12603                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12604                         break; }
12605
12606                         case 3: {
12607                         break; }
12608
12609                         default: {
12610                         break; }
12611
12612                 }
12613         }
12614         if (ndr_flags & NDR_BUFFERS) {
12615                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12616                 switch (level) {
12617                         case 1:
12618                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12619                         break;
12620
12621                         case 2:
12622                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12623                         break;
12624
12625                         case 3:
12626                         break;
12627
12628                         default:
12629                         break;
12630
12631                 }
12632         }
12633         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12634         return NDR_ERR_SUCCESS;
12635 }
12636
12637 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
12638 {
12639         int level;
12640         level = ndr_print_get_switch_value(ndr, r);
12641         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
12642         switch (level) {
12643                 case 1:
12644                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
12645                 break;
12646
12647                 case 2:
12648                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
12649                 break;
12650
12651                 case 3:
12652                 break;
12653
12654                 default:
12655                 break;
12656
12657         }
12658 }
12659
12660 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
12661 {
12662         if (ndr_flags & NDR_SCALARS) {
12663                 NDR_CHECK(ndr_push_align(ndr, 4));
12664                 {
12665                         uint32_t _flags_save_string = ndr->flags;
12666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12667                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12668                         ndr->flags = _flags_save_string;
12669                 }
12670         }
12671         if (ndr_flags & NDR_BUFFERS) {
12672                 {
12673                         uint32_t _flags_save_string = ndr->flags;
12674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12675                         if (r->monitor_name) {
12676                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12678                         }
12679                         ndr->flags = _flags_save_string;
12680                 }
12681         }
12682         return NDR_ERR_SUCCESS;
12683 }
12684
12685 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
12686 {
12687         uint32_t _ptr_monitor_name;
12688         TALLOC_CTX *_mem_save_monitor_name_0;
12689         if (ndr_flags & NDR_SCALARS) {
12690                 NDR_CHECK(ndr_pull_align(ndr, 4));
12691                 {
12692                         uint32_t _flags_save_string = ndr->flags;
12693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12694                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12695                         if (_ptr_monitor_name) {
12696                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12697                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12698                         } else {
12699                                 r->monitor_name = NULL;
12700                         }
12701                         ndr->flags = _flags_save_string;
12702                 }
12703         }
12704         if (ndr_flags & NDR_BUFFERS) {
12705                 {
12706                         uint32_t _flags_save_string = ndr->flags;
12707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12708                         if (r->monitor_name) {
12709                                 uint32_t _relative_save_offset;
12710                                 _relative_save_offset = ndr->offset;
12711                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12712                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12713                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12714                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12715                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12716                                 ndr->offset = _relative_save_offset;
12717                         }
12718                         ndr->flags = _flags_save_string;
12719                 }
12720         }
12721         return NDR_ERR_SUCCESS;
12722 }
12723
12724 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
12725 {
12726         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
12727         ndr->depth++;
12728         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12729         ndr->depth++;
12730         if (r->monitor_name) {
12731                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12732         }
12733         ndr->depth--;
12734         ndr->depth--;
12735 }
12736
12737 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
12738 {
12739         if (ndr_flags & NDR_SCALARS) {
12740                 NDR_CHECK(ndr_push_align(ndr, 4));
12741                 {
12742                         uint32_t _flags_save_string = ndr->flags;
12743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12745                         ndr->flags = _flags_save_string;
12746                 }
12747                 {
12748                         uint32_t _flags_save_string = ndr->flags;
12749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
12751                         ndr->flags = _flags_save_string;
12752                 }
12753                 {
12754                         uint32_t _flags_save_string = ndr->flags;
12755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
12757                         ndr->flags = _flags_save_string;
12758                 }
12759         }
12760         if (ndr_flags & NDR_BUFFERS) {
12761                 {
12762                         uint32_t _flags_save_string = ndr->flags;
12763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12764                         if (r->monitor_name) {
12765                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12766                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12767                         }
12768                         ndr->flags = _flags_save_string;
12769                 }
12770                 {
12771                         uint32_t _flags_save_string = ndr->flags;
12772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12773                         if (r->environment) {
12774                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
12775                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
12776                         }
12777                         ndr->flags = _flags_save_string;
12778                 }
12779                 {
12780                         uint32_t _flags_save_string = ndr->flags;
12781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12782                         if (r->dll_name) {
12783                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
12784                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
12785                         }
12786                         ndr->flags = _flags_save_string;
12787                 }
12788         }
12789         return NDR_ERR_SUCCESS;
12790 }
12791
12792 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
12793 {
12794         uint32_t _ptr_monitor_name;
12795         TALLOC_CTX *_mem_save_monitor_name_0;
12796         uint32_t _ptr_environment;
12797         TALLOC_CTX *_mem_save_environment_0;
12798         uint32_t _ptr_dll_name;
12799         TALLOC_CTX *_mem_save_dll_name_0;
12800         if (ndr_flags & NDR_SCALARS) {
12801                 NDR_CHECK(ndr_pull_align(ndr, 4));
12802                 {
12803                         uint32_t _flags_save_string = ndr->flags;
12804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12805                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12806                         if (_ptr_monitor_name) {
12807                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12808                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12809                         } else {
12810                                 r->monitor_name = NULL;
12811                         }
12812                         ndr->flags = _flags_save_string;
12813                 }
12814                 {
12815                         uint32_t _flags_save_string = ndr->flags;
12816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12817                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
12818                         if (_ptr_environment) {
12819                                 NDR_PULL_ALLOC(ndr, r->environment);
12820                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
12821                         } else {
12822                                 r->environment = NULL;
12823                         }
12824                         ndr->flags = _flags_save_string;
12825                 }
12826                 {
12827                         uint32_t _flags_save_string = ndr->flags;
12828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12829                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
12830                         if (_ptr_dll_name) {
12831                                 NDR_PULL_ALLOC(ndr, r->dll_name);
12832                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
12833                         } else {
12834                                 r->dll_name = NULL;
12835                         }
12836                         ndr->flags = _flags_save_string;
12837                 }
12838         }
12839         if (ndr_flags & NDR_BUFFERS) {
12840                 {
12841                         uint32_t _flags_save_string = ndr->flags;
12842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12843                         if (r->monitor_name) {
12844                                 uint32_t _relative_save_offset;
12845                                 _relative_save_offset = ndr->offset;
12846                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12847                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12848                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12849                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12850                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12851                                 ndr->offset = _relative_save_offset;
12852                         }
12853                         ndr->flags = _flags_save_string;
12854                 }
12855                 {
12856                         uint32_t _flags_save_string = ndr->flags;
12857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12858                         if (r->environment) {
12859                                 uint32_t _relative_save_offset;
12860                                 _relative_save_offset = ndr->offset;
12861                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
12862                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
12863                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
12864                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
12865                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
12866                                 ndr->offset = _relative_save_offset;
12867                         }
12868                         ndr->flags = _flags_save_string;
12869                 }
12870                 {
12871                         uint32_t _flags_save_string = ndr->flags;
12872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12873                         if (r->dll_name) {
12874                                 uint32_t _relative_save_offset;
12875                                 _relative_save_offset = ndr->offset;
12876                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
12877                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12878                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
12879                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
12880                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
12881                                 ndr->offset = _relative_save_offset;
12882                         }
12883                         ndr->flags = _flags_save_string;
12884                 }
12885         }
12886         return NDR_ERR_SUCCESS;
12887 }
12888
12889 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
12890 {
12891         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
12892         ndr->depth++;
12893         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12894         ndr->depth++;
12895         if (r->monitor_name) {
12896                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12897         }
12898         ndr->depth--;
12899         ndr_print_ptr(ndr, "environment", r->environment);
12900         ndr->depth++;
12901         if (r->environment) {
12902                 ndr_print_string(ndr, "environment", r->environment);
12903         }
12904         ndr->depth--;
12905         ndr_print_ptr(ndr, "dll_name", r->dll_name);
12906         ndr->depth++;
12907         if (r->dll_name) {
12908                 ndr_print_string(ndr, "dll_name", r->dll_name);
12909         }
12910         ndr->depth--;
12911         ndr->depth--;
12912 }
12913
12914 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
12915 {
12916         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12917         if (ndr_flags & NDR_SCALARS) {
12918                 int level = ndr_push_get_switch_value(ndr, r);
12919                 switch (level) {
12920                         case 1: {
12921                                 NDR_CHECK(ndr_push_align(ndr, 4));
12922                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12923                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12924                         break; }
12925
12926                         case 2: {
12927                                 NDR_CHECK(ndr_push_align(ndr, 4));
12928                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12929                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12930                         break; }
12931
12932                         default: {
12933                         break; }
12934
12935                 }
12936         }
12937         if (ndr_flags & NDR_BUFFERS) {
12938                 int level = ndr_push_get_switch_value(ndr, r);
12939                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12940                 switch (level) {
12941                         case 1:
12942                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12943                         break;
12944
12945                         case 2:
12946                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12947                         break;
12948
12949                         default:
12950                         break;
12951
12952                 }
12953         }
12954         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12955         return NDR_ERR_SUCCESS;
12956 }
12957
12958 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
12959 {
12960         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12961         int level;
12962         level = ndr_pull_get_switch_value(ndr, r);
12963         if (ndr_flags & NDR_SCALARS) {
12964                 switch (level) {
12965                         case 1: {
12966                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12967                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12968                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12969                         break; }
12970
12971                         case 2: {
12972                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12973                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12974                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12975                         break; }
12976
12977                         default: {
12978                         break; }
12979
12980                 }
12981         }
12982         if (ndr_flags & NDR_BUFFERS) {
12983                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12984                 switch (level) {
12985                         case 1:
12986                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12987                         break;
12988
12989                         case 2:
12990                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12991                         break;
12992
12993                         default:
12994                         break;
12995
12996                 }
12997         }
12998         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12999         return NDR_ERR_SUCCESS;
13000 }
13001
13002 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
13003 {
13004         int level;
13005         level = ndr_print_get_switch_value(ndr, r);
13006         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
13007         switch (level) {
13008                 case 1:
13009                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
13010                 break;
13011
13012                 case 2:
13013                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
13014                 break;
13015
13016                 default:
13017                 break;
13018
13019         }
13020 }
13021
13022 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13023 {
13024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13025         return NDR_ERR_SUCCESS;
13026 }
13027
13028 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13029 {
13030         uint32_t v;
13031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13032         *r = v;
13033         return NDR_ERR_SUCCESS;
13034 }
13035
13036 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13037 {
13038         ndr_print_uint32(ndr, name, r);
13039         ndr->depth++;
13040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
13041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
13042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
13043         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
13044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
13045         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
13046         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
13047         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
13048         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
13049         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
13050         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
13051         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
13052         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
13053         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
13054         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
13055         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
13056         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
13057         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
13058         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
13059         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
13060         ndr->depth--;
13061 }
13062
13063 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
13064 {
13065         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13066         return NDR_ERR_SUCCESS;
13067 }
13068
13069 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
13070 {
13071         uint16_t v;
13072         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13073         *r = v;
13074         return NDR_ERR_SUCCESS;
13075 }
13076
13077 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
13078 {
13079         const char *val = NULL;
13080
13081         switch (r) {
13082                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
13083                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
13084                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
13085                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
13086                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
13087                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
13088                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
13089                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
13090                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
13091                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
13092                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
13093                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
13094                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
13095                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
13096                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
13097                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
13098                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
13099                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
13100                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
13101                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
13102                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
13103                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
13104                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
13105                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
13106                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
13107                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
13108         }
13109         ndr_print_enum(ndr, name, "ENUM", val, r);
13110 }
13111
13112 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
13113 {
13114         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13115         return NDR_ERR_SUCCESS;
13116 }
13117
13118 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
13119 {
13120         uint16_t v;
13121         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13122         *r = v;
13123         return NDR_ERR_SUCCESS;
13124 }
13125
13126 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
13127 {
13128         const char *val = NULL;
13129
13130         switch (r) {
13131                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
13132                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
13133         }
13134         ndr_print_enum(ndr, name, "ENUM", val, r);
13135 }
13136
13137 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
13138 {
13139         uint32_t cntr_fields_1;
13140         if (ndr_flags & NDR_SCALARS) {
13141                 NDR_CHECK(ndr_push_align(ndr, 4));
13142                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13143                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
13144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
13145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
13146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13147                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
13148         }
13149         if (ndr_flags & NDR_BUFFERS) {
13150                 if (r->fields) {
13151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13152                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13153                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
13154                         }
13155                 }
13156         }
13157         return NDR_ERR_SUCCESS;
13158 }
13159
13160 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
13161 {
13162         uint32_t _ptr_fields;
13163         uint32_t cntr_fields_1;
13164         TALLOC_CTX *_mem_save_fields_0;
13165         TALLOC_CTX *_mem_save_fields_1;
13166         if (ndr_flags & NDR_SCALARS) {
13167                 NDR_CHECK(ndr_pull_align(ndr, 4));
13168                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13169                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
13170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
13171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
13172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13173                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
13174                 if (_ptr_fields) {
13175                         NDR_PULL_ALLOC(ndr, r->fields);
13176                 } else {
13177                         r->fields = NULL;
13178                 }
13179         }
13180         if (ndr_flags & NDR_BUFFERS) {
13181                 if (r->fields) {
13182                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
13183                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
13185                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
13186                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
13187                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13188                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13189                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
13190                         }
13191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
13192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
13193                 }
13194                 if (r->fields) {
13195                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
13196                 }
13197         }
13198         return NDR_ERR_SUCCESS;
13199 }
13200
13201 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
13202 {
13203         uint32_t cntr_fields_1;
13204         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
13205         ndr->depth++;
13206         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13207         ndr_print_uint16(ndr, "u1", r->u1);
13208         ndr_print_uint32(ndr, "u2", r->u2);
13209         ndr_print_uint32(ndr, "u3", r->u3);
13210         ndr_print_uint32(ndr, "count", r->count);
13211         ndr_print_ptr(ndr, "fields", r->fields);
13212         ndr->depth++;
13213         if (r->fields) {
13214                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
13215                 ndr->depth++;
13216                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
13217                         char *idx_1=NULL;
13218                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
13219                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
13220                                 free(idx_1);
13221                         }
13222                 }
13223                 ndr->depth--;
13224         }
13225         ndr->depth--;
13226         ndr->depth--;
13227 }
13228
13229 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13230 {
13231         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13232         return NDR_ERR_SUCCESS;
13233 }
13234
13235 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13236 {
13237         uint32_t v;
13238         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13239         *r = v;
13240         return NDR_ERR_SUCCESS;
13241 }
13242
13243 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13244 {
13245         ndr_print_uint32(ndr, name, r);
13246         ndr->depth++;
13247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
13248         ndr->depth--;
13249 }
13250
13251 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
13252 {
13253         uint32_t cntr_types_1;
13254         if (ndr_flags & NDR_SCALARS) {
13255                 NDR_CHECK(ndr_push_align(ndr, 4));
13256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13257                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
13258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
13260         }
13261         if (ndr_flags & NDR_BUFFERS) {
13262                 if (r->types) {
13263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13264                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13265                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13266                         }
13267                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13268                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13269                         }
13270                 }
13271         }
13272         return NDR_ERR_SUCCESS;
13273 }
13274
13275 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
13276 {
13277         uint32_t _ptr_types;
13278         uint32_t cntr_types_1;
13279         TALLOC_CTX *_mem_save_types_0;
13280         TALLOC_CTX *_mem_save_types_1;
13281         if (ndr_flags & NDR_SCALARS) {
13282                 NDR_CHECK(ndr_pull_align(ndr, 4));
13283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13284                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
13285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
13287                 if (_ptr_types) {
13288                         NDR_PULL_ALLOC(ndr, r->types);
13289                 } else {
13290                         r->types = NULL;
13291                 }
13292         }
13293         if (ndr_flags & NDR_BUFFERS) {
13294                 if (r->types) {
13295                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
13296                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13297                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
13298                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
13299                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
13300                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13301                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13302                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13303                         }
13304                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13305                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13306                         }
13307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
13308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
13309                 }
13310                 if (r->types) {
13311                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
13312                 }
13313         }
13314         return NDR_ERR_SUCCESS;
13315 }
13316
13317 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
13318 {
13319         uint32_t cntr_types_1;
13320         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
13321         ndr->depth++;
13322         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13323         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
13324         ndr_print_uint32(ndr, "count", r->count);
13325         ndr_print_ptr(ndr, "types", r->types);
13326         ndr->depth++;
13327         if (r->types) {
13328                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
13329                 ndr->depth++;
13330                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
13331                         char *idx_1=NULL;
13332                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
13333                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
13334                                 free(idx_1);
13335                         }
13336                 }
13337                 ndr->depth--;
13338         }
13339         ndr->depth--;
13340         ndr->depth--;
13341 }
13342
13343 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
13344 {
13345         if (ndr_flags & NDR_SCALARS) {
13346                 NDR_CHECK(ndr_push_align(ndr, 4));
13347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
13349         }
13350         if (ndr_flags & NDR_BUFFERS) {
13351                 if (r->string) {
13352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
13353                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
13354                 }
13355         }
13356         return NDR_ERR_SUCCESS;
13357 }
13358
13359 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
13360 {
13361         uint32_t _ptr_string;
13362         TALLOC_CTX *_mem_save_string_0;
13363         if (ndr_flags & NDR_SCALARS) {
13364                 NDR_CHECK(ndr_pull_align(ndr, 4));
13365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
13367                 if (_ptr_string) {
13368                         NDR_PULL_ALLOC(ndr, r->string);
13369                 } else {
13370                         r->string = NULL;
13371                 }
13372         }
13373         if (ndr_flags & NDR_BUFFERS) {
13374                 if (r->string) {
13375                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
13376                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
13377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
13378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
13379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
13380                 }
13381                 if (r->string) {
13382                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
13383                 }
13384         }
13385         return NDR_ERR_SUCCESS;
13386 }
13387
13388 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
13389 {
13390         ndr_print_struct(ndr, name, "spoolss_NotifyString");
13391         ndr->depth++;
13392         ndr_print_uint32(ndr, "size", r->size);
13393         ndr_print_ptr(ndr, "string", r->string);
13394         ndr->depth++;
13395         if (r->string) {
13396                 ndr_print_string(ndr, "string", r->string);
13397         }
13398         ndr->depth--;
13399         ndr->depth--;
13400 }
13401
13402 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
13403 {
13404         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13405         return NDR_ERR_SUCCESS;
13406 }
13407
13408 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
13409 {
13410         uint32_t v;
13411         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13412         *r = v;
13413         return NDR_ERR_SUCCESS;
13414 }
13415
13416 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
13417 {
13418         const char *val = NULL;
13419
13420         switch (r) {
13421                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
13422                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
13423                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
13424                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
13425                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
13426         }
13427         ndr_print_enum(ndr, name, "ENUM", val, r);
13428 }
13429
13430 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
13431 {
13432         if (ndr_flags & NDR_SCALARS) {
13433                 int level = ndr_push_get_switch_value(ndr, r);
13434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13435                 switch (level) {
13436                         case 1: {
13437                                 uint32_t cntr_integer_0;
13438                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13439                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
13440                                 }
13441                         break; }
13442
13443                         case 2: {
13444                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13445                         break; }
13446
13447                         case 3: {
13448                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
13449                         break; }
13450
13451                         case 4: {
13452                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13453                         break; }
13454
13455                         case 5: {
13456                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13457                         break; }
13458
13459                         default:
13460                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13461                 }
13462         }
13463         if (ndr_flags & NDR_BUFFERS) {
13464                 int level = ndr_push_get_switch_value(ndr, r);
13465                 switch (level) {
13466                         case 1:
13467                         break;
13468
13469                         case 2:
13470                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13471                         break;
13472
13473                         case 3:
13474                                 if (r->devmode) {
13475                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
13476                                 }
13477                         break;
13478
13479                         case 4:
13480                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13481                         break;
13482
13483                         case 5:
13484                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13485                         break;
13486
13487                         default:
13488                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13489                 }
13490         }
13491         return NDR_ERR_SUCCESS;
13492 }
13493
13494 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
13495 {
13496         int level;
13497         uint32_t _level;
13498         TALLOC_CTX *_mem_save_devmode_0;
13499         level = ndr_pull_get_switch_value(ndr, r);
13500         if (ndr_flags & NDR_SCALARS) {
13501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13502                 if (_level != level) {
13503                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13504                 }
13505                 switch (level) {
13506                         case 1: {
13507                                 uint32_t cntr_integer_0;
13508                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13509                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
13510                                 }
13511                         break; }
13512
13513                         case 2: {
13514                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13515                         break; }
13516
13517                         case 3: {
13518                                 uint32_t _ptr_devmode;
13519                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
13520                                 if (_ptr_devmode) {
13521                                         NDR_PULL_ALLOC(ndr, r->devmode);
13522                                 } else {
13523                                         r->devmode = NULL;
13524                                 }
13525                         break; }
13526
13527                         case 4: {
13528                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13529                         break; }
13530
13531                         case 5: {
13532                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13533                         break; }
13534
13535                         default:
13536                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13537                 }
13538         }
13539         if (ndr_flags & NDR_BUFFERS) {
13540                 switch (level) {
13541                         case 1:
13542                         break;
13543
13544                         case 2:
13545                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13546                         break;
13547
13548                         case 3:
13549                                 if (r->devmode) {
13550                                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
13551                                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
13552                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
13553                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
13554                                 }
13555                         break;
13556
13557                         case 4:
13558                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13559                         break;
13560
13561                         case 5:
13562                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13563                         break;
13564
13565                         default:
13566                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13567                 }
13568         }
13569         return NDR_ERR_SUCCESS;
13570 }
13571
13572 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
13573 {
13574         int level;
13575         uint32_t cntr_integer_0;
13576         level = ndr_print_get_switch_value(ndr, r);
13577         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
13578         switch (level) {
13579                 case 1:
13580                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
13581                         ndr->depth++;
13582                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
13583                                 char *idx_0=NULL;
13584                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
13585                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
13586                                         free(idx_0);
13587                                 }
13588                         }
13589                         ndr->depth--;
13590                 break;
13591
13592                 case 2:
13593                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
13594                 break;
13595
13596                 case 3:
13597                         ndr_print_ptr(ndr, "devmode", r->devmode);
13598                         ndr->depth++;
13599                         if (r->devmode) {
13600                                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
13601                         }
13602                         ndr->depth--;
13603                 break;
13604
13605                 case 4:
13606                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
13607                 break;
13608
13609                 case 5:
13610                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
13611                 break;
13612
13613                 default:
13614                         ndr_print_bad_level(ndr, name, level);
13615         }
13616 }
13617
13618 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
13619 {
13620         if (ndr_flags & NDR_SCALARS) {
13621                 NDR_CHECK(ndr_push_align(ndr, 4));
13622                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13623                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
13624                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
13625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
13626                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
13627                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13628         }
13629         if (ndr_flags & NDR_BUFFERS) {
13630                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13631         }
13632         return NDR_ERR_SUCCESS;
13633 }
13634
13635 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
13636 {
13637         if (ndr_flags & NDR_SCALARS) {
13638                 NDR_CHECK(ndr_pull_align(ndr, 4));
13639                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13640                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
13641                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
13642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
13643                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
13644                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13645         }
13646         if (ndr_flags & NDR_BUFFERS) {
13647                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13648         }
13649         return NDR_ERR_SUCCESS;
13650 }
13651
13652 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
13653 {
13654         ndr_print_struct(ndr, name, "spoolss_Notify");
13655         ndr->depth++;
13656         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13657         ndr_print_spoolss_Field(ndr, "field", r->field);
13658         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
13659         ndr_print_uint32(ndr, "job_id", r->job_id);
13660         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
13661         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
13662         ndr->depth--;
13663 }
13664
13665 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
13666 {
13667         uint32_t cntr_notifies_0;
13668         if (ndr_flags & NDR_SCALARS) {
13669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13670                 NDR_CHECK(ndr_push_align(ndr, 4));
13671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13674                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13675                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13676                 }
13677         }
13678         if (ndr_flags & NDR_BUFFERS) {
13679                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13680                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13681                 }
13682         }
13683         return NDR_ERR_SUCCESS;
13684 }
13685
13686 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
13687 {
13688         uint32_t cntr_notifies_0;
13689         TALLOC_CTX *_mem_save_notifies_0;
13690         if (ndr_flags & NDR_SCALARS) {
13691                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
13692                 NDR_CHECK(ndr_pull_align(ndr, 4));
13693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13696                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
13697                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13698                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13699                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13700                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13701                 }
13702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13703                 if (r->notifies) {
13704                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
13705                 }
13706         }
13707         if (ndr_flags & NDR_BUFFERS) {
13708                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13709                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13710                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13711                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13712                 }
13713                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13714         }
13715         return NDR_ERR_SUCCESS;
13716 }
13717
13718 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
13719 {
13720         uint32_t cntr_notifies_0;
13721         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
13722         ndr->depth++;
13723         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13724         ndr_print_uint32(ndr, "flags", r->flags);
13725         ndr_print_uint32(ndr, "count", r->count);
13726         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
13727         ndr->depth++;
13728         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
13729                 char *idx_0=NULL;
13730                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
13731                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
13732                         free(idx_0);
13733                 }
13734         }
13735         ndr->depth--;
13736         ndr->depth--;
13737 }
13738
13739 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
13740 {
13741         if (ndr_flags & NDR_SCALARS) {
13742                 int level = ndr_push_get_switch_value(ndr, r);
13743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13744                 switch (level) {
13745                         case 0: {
13746                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
13747                         break; }
13748
13749                         default:
13750                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13751                 }
13752         }
13753         if (ndr_flags & NDR_BUFFERS) {
13754                 int level = ndr_push_get_switch_value(ndr, r);
13755                 switch (level) {
13756                         case 0:
13757                                 if (r->info0) {
13758                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13759                                 }
13760                         break;
13761
13762                         default:
13763                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13764                 }
13765         }
13766         return NDR_ERR_SUCCESS;
13767 }
13768
13769 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
13770 {
13771         int level;
13772         uint32_t _level;
13773         TALLOC_CTX *_mem_save_info0_0;
13774         level = ndr_pull_get_switch_value(ndr, r);
13775         if (ndr_flags & NDR_SCALARS) {
13776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13777                 if (_level != level) {
13778                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13779                 }
13780                 switch (level) {
13781                         case 0: {
13782                                 uint32_t _ptr_info0;
13783                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
13784                                 if (_ptr_info0) {
13785                                         NDR_PULL_ALLOC(ndr, r->info0);
13786                                 } else {
13787                                         r->info0 = NULL;
13788                                 }
13789                         break; }
13790
13791                         default:
13792                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13793                 }
13794         }
13795         if (ndr_flags & NDR_BUFFERS) {
13796                 switch (level) {
13797                         case 0:
13798                                 if (r->info0) {
13799                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
13800                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
13801                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13802                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
13803                                 }
13804                         break;
13805
13806                         default:
13807                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13808                 }
13809         }
13810         return NDR_ERR_SUCCESS;
13811 }
13812
13813 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
13814 {
13815         int level;
13816         level = ndr_print_get_switch_value(ndr, r);
13817         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
13818         switch (level) {
13819                 case 0:
13820                         ndr_print_ptr(ndr, "info0", r->info0);
13821                         ndr->depth++;
13822                         if (r->info0) {
13823                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
13824                         }
13825                         ndr->depth--;
13826                 break;
13827
13828                 default:
13829                         ndr_print_bad_level(ndr, name, level);
13830         }
13831 }
13832
13833 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13834 {
13835         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13836         return NDR_ERR_SUCCESS;
13837 }
13838
13839 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13840 {
13841         uint32_t v;
13842         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13843         *r = v;
13844         return NDR_ERR_SUCCESS;
13845 }
13846
13847 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13848 {
13849         ndr_print_uint32(ndr, name, r);
13850         ndr->depth++;
13851         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
13852         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
13853         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
13854         ndr->depth--;
13855 }
13856
13857 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
13858 {
13859         if (ndr_flags & NDR_SCALARS) {
13860                 NDR_CHECK(ndr_push_align(ndr, 4));
13861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
13863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
13864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13865                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
13866                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
13867                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
13868         }
13869         if (ndr_flags & NDR_BUFFERS) {
13870                 if (r->client) {
13871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13872                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13874                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13875                 }
13876                 if (r->user) {
13877                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13880                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13881                 }
13882         }
13883         return NDR_ERR_SUCCESS;
13884 }
13885
13886 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
13887 {
13888         uint32_t _ptr_client;
13889         TALLOC_CTX *_mem_save_client_0;
13890         uint32_t _ptr_user;
13891         TALLOC_CTX *_mem_save_user_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_client));
13896                 if (_ptr_client) {
13897                         NDR_PULL_ALLOC(ndr, r->client);
13898                 } else {
13899                         r->client = NULL;
13900                 }
13901                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13902                 if (_ptr_user) {
13903                         NDR_PULL_ALLOC(ndr, r->user);
13904                 } else {
13905                         r->user = NULL;
13906                 }
13907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13908                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
13909                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
13910                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
13911         }
13912         if (ndr_flags & NDR_BUFFERS) {
13913                 if (r->client) {
13914                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
13915                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
13916                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
13917                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
13918                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
13919                                 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));
13920                         }
13921                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
13922                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
13923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
13924                 }
13925                 if (r->user) {
13926                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13927                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
13928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
13929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
13930                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
13931                                 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));
13932                         }
13933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
13934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
13935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13936                 }
13937         }
13938         return NDR_ERR_SUCCESS;
13939 }
13940
13941 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
13942 {
13943         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
13944         ndr->depth++;
13945         ndr_print_uint32(ndr, "size", r->size);
13946         ndr_print_ptr(ndr, "client", r->client);
13947         ndr->depth++;
13948         if (r->client) {
13949                 ndr_print_string(ndr, "client", r->client);
13950         }
13951         ndr->depth--;
13952         ndr_print_ptr(ndr, "user", r->user);
13953         ndr->depth++;
13954         if (r->user) {
13955                 ndr_print_string(ndr, "user", r->user);
13956         }
13957         ndr->depth--;
13958         ndr_print_uint32(ndr, "build", r->build);
13959         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
13960         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
13961         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
13962         ndr->depth--;
13963 }
13964
13965 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
13966 {
13967         if (ndr_flags & NDR_SCALARS) {
13968                 NDR_CHECK(ndr_push_align(ndr, 4));
13969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
13970         }
13971         if (ndr_flags & NDR_BUFFERS) {
13972         }
13973         return NDR_ERR_SUCCESS;
13974 }
13975
13976 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
13977 {
13978         if (ndr_flags & NDR_SCALARS) {
13979                 NDR_CHECK(ndr_pull_align(ndr, 4));
13980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
13981         }
13982         if (ndr_flags & NDR_BUFFERS) {
13983         }
13984         return NDR_ERR_SUCCESS;
13985 }
13986
13987 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
13988 {
13989         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
13990         ndr->depth++;
13991         ndr_print_uint32(ndr, "not_used", r->not_used);
13992         ndr->depth--;
13993 }
13994
13995 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
13996 {
13997         if (ndr_flags & NDR_SCALARS) {
13998                 NDR_CHECK(ndr_push_align(ndr, 4));
13999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
14000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
14001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
14002                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
14003                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
14004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14005                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
14006                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
14007                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
14008                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
14009         }
14010         if (ndr_flags & NDR_BUFFERS) {
14011                 if (r->client) {
14012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14015                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14016                 }
14017                 if (r->user) {
14018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14021                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14022                 }
14023         }
14024         return NDR_ERR_SUCCESS;
14025 }
14026
14027 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
14028 {
14029         uint32_t _ptr_client;
14030         TALLOC_CTX *_mem_save_client_0;
14031         uint32_t _ptr_user;
14032         TALLOC_CTX *_mem_save_user_0;
14033         if (ndr_flags & NDR_SCALARS) {
14034                 NDR_CHECK(ndr_pull_align(ndr, 4));
14035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
14037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
14038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14039                 if (_ptr_client) {
14040                         NDR_PULL_ALLOC(ndr, r->client);
14041                 } else {
14042                         r->client = NULL;
14043                 }
14044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14045                 if (_ptr_user) {
14046                         NDR_PULL_ALLOC(ndr, r->user);
14047                 } else {
14048                         r->user = NULL;
14049                 }
14050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14051                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
14052                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
14053                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
14054                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
14055         }
14056         if (ndr_flags & NDR_BUFFERS) {
14057                 if (r->client) {
14058                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14059                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
14060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
14061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
14062                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
14063                                 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));
14064                         }
14065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
14066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
14067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14068                 }
14069                 if (r->user) {
14070                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14071                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
14072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
14073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
14074                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
14075                                 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));
14076                         }
14077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
14078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
14079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14080                 }
14081         }
14082         return NDR_ERR_SUCCESS;
14083 }
14084
14085 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
14086 {
14087         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
14088         ndr->depth++;
14089         ndr_print_uint32(ndr, "size", r->size);
14090         ndr_print_uint32(ndr, "flags", r->flags);
14091         ndr_print_uint32(ndr, "size2", r->size2);
14092         ndr_print_ptr(ndr, "client", r->client);
14093         ndr->depth++;
14094         if (r->client) {
14095                 ndr_print_string(ndr, "client", r->client);
14096         }
14097         ndr->depth--;
14098         ndr_print_ptr(ndr, "user", r->user);
14099         ndr->depth++;
14100         if (r->user) {
14101                 ndr_print_string(ndr, "user", r->user);
14102         }
14103         ndr->depth--;
14104         ndr_print_uint32(ndr, "build", r->build);
14105         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
14106         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
14107         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
14108         ndr_print_udlong(ndr, "reserved", r->reserved);
14109         ndr->depth--;
14110 }
14111
14112 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
14113 {
14114         if (ndr_flags & NDR_SCALARS) {
14115                 int level = ndr_push_get_switch_value(ndr, r);
14116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14117                 switch (level) {
14118                         case 1: {
14119                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
14120                         break; }
14121
14122                         case 2: {
14123                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
14124                         break; }
14125
14126                         case 3: {
14127                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
14128                         break; }
14129
14130                         default:
14131                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14132                 }
14133         }
14134         if (ndr_flags & NDR_BUFFERS) {
14135                 int level = ndr_push_get_switch_value(ndr, r);
14136                 switch (level) {
14137                         case 1:
14138                                 if (r->level1) {
14139                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14140                                 }
14141                         break;
14142
14143                         case 2:
14144                                 if (r->level2) {
14145                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14146                                 }
14147                         break;
14148
14149                         case 3:
14150                                 if (r->level3) {
14151                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14152                                 }
14153                         break;
14154
14155                         default:
14156                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14157                 }
14158         }
14159         return NDR_ERR_SUCCESS;
14160 }
14161
14162 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
14163 {
14164         int level;
14165         uint32_t _level;
14166         TALLOC_CTX *_mem_save_level1_0;
14167         TALLOC_CTX *_mem_save_level2_0;
14168         TALLOC_CTX *_mem_save_level3_0;
14169         level = ndr_pull_get_switch_value(ndr, r);
14170         if (ndr_flags & NDR_SCALARS) {
14171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14172                 if (_level != level) {
14173                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14174                 }
14175                 switch (level) {
14176                         case 1: {
14177                                 uint32_t _ptr_level1;
14178                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
14179                                 if (_ptr_level1) {
14180                                         NDR_PULL_ALLOC(ndr, r->level1);
14181                                 } else {
14182                                         r->level1 = NULL;
14183                                 }
14184                         break; }
14185
14186                         case 2: {
14187                                 uint32_t _ptr_level2;
14188                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
14189                                 if (_ptr_level2) {
14190                                         NDR_PULL_ALLOC(ndr, r->level2);
14191                                 } else {
14192                                         r->level2 = NULL;
14193                                 }
14194                         break; }
14195
14196                         case 3: {
14197                                 uint32_t _ptr_level3;
14198                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
14199                                 if (_ptr_level3) {
14200                                         NDR_PULL_ALLOC(ndr, r->level3);
14201                                 } else {
14202                                         r->level3 = NULL;
14203                                 }
14204                         break; }
14205
14206                         default:
14207                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14208                 }
14209         }
14210         if (ndr_flags & NDR_BUFFERS) {
14211                 switch (level) {
14212                         case 1:
14213                                 if (r->level1) {
14214                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14215                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
14216                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14217                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
14218                                 }
14219                         break;
14220
14221                         case 2:
14222                                 if (r->level2) {
14223                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
14224                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
14225                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14226                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
14227                                 }
14228                         break;
14229
14230                         case 3:
14231                                 if (r->level3) {
14232                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
14233                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
14234                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14235                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
14236                                 }
14237                         break;
14238
14239                         default:
14240                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14241                 }
14242         }
14243         return NDR_ERR_SUCCESS;
14244 }
14245
14246 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
14247 {
14248         int level;
14249         level = ndr_print_get_switch_value(ndr, r);
14250         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
14251         switch (level) {
14252                 case 1:
14253                         ndr_print_ptr(ndr, "level1", r->level1);
14254                         ndr->depth++;
14255                         if (r->level1) {
14256                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
14257                         }
14258                         ndr->depth--;
14259                 break;
14260
14261                 case 2:
14262                         ndr_print_ptr(ndr, "level2", r->level2);
14263                         ndr->depth++;
14264                         if (r->level2) {
14265                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
14266                         }
14267                         ndr->depth--;
14268                 break;
14269
14270                 case 3:
14271                         ndr_print_ptr(ndr, "level3", r->level3);
14272                         ndr->depth++;
14273                         if (r->level3) {
14274                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
14275                         }
14276                         ndr->depth--;
14277                 break;
14278
14279                 default:
14280                         ndr_print_bad_level(ndr, name, level);
14281         }
14282 }
14283
14284 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
14285 {
14286         if (ndr_flags & NDR_SCALARS) {
14287                 NDR_CHECK(ndr_push_align(ndr, 4));
14288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
14289                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
14290                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14291         }
14292         if (ndr_flags & NDR_BUFFERS) {
14293                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14294         }
14295         return NDR_ERR_SUCCESS;
14296 }
14297
14298 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
14299 {
14300         if (ndr_flags & NDR_SCALARS) {
14301                 NDR_CHECK(ndr_pull_align(ndr, 4));
14302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
14303                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
14304                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14305         }
14306         if (ndr_flags & NDR_BUFFERS) {
14307                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14308         }
14309         return NDR_ERR_SUCCESS;
14310 }
14311
14312 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
14313 {
14314         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
14315         ndr->depth++;
14316         ndr_print_uint32(ndr, "level", r->level);
14317         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
14318         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
14319         ndr->depth--;
14320 }
14321
14322 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14323 {
14324         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14325         return NDR_ERR_SUCCESS;
14326 }
14327
14328 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14329 {
14330         uint32_t v;
14331         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14332         *r = v;
14333         return NDR_ERR_SUCCESS;
14334 }
14335
14336 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
14337 {
14338         ndr_print_uint32(ndr, name, r);
14339         ndr->depth++;
14340         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
14341         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
14342         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
14343         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
14344         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
14345         ndr->depth--;
14346 }
14347
14348 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14349 {
14350         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14351         return NDR_ERR_SUCCESS;
14352 }
14353
14354 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14355 {
14356         uint32_t v;
14357         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14358         *r = v;
14359         return NDR_ERR_SUCCESS;
14360 }
14361
14362 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14363 {
14364         ndr_print_uint32(ndr, name, r);
14365         ndr->depth++;
14366         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
14367         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
14368         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
14369         ndr->depth--;
14370 }
14371
14372 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
14373 {
14374         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14375         return NDR_ERR_SUCCESS;
14376 }
14377
14378 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
14379 {
14380         uint32_t v;
14381         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14382         *r = v;
14383         return NDR_ERR_SUCCESS;
14384 }
14385
14386 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
14387 {
14388         const char *val = NULL;
14389
14390         switch (r) {
14391                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
14392                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
14393         }
14394         ndr_print_enum(ndr, name, "ENUM", val, r);
14395 }
14396
14397 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
14398 {
14399         if (ndr_flags & NDR_SCALARS) {
14400                 NDR_CHECK(ndr_push_align(ndr, 4));
14401                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
14403                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14406                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14407                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14409                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14410                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14411                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14412                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14416         }
14417         if (ndr_flags & NDR_BUFFERS) {
14418         }
14419         return NDR_ERR_SUCCESS;
14420 }
14421
14422 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
14423 {
14424         if (ndr_flags & NDR_SCALARS) {
14425                 NDR_CHECK(ndr_pull_align(ndr, 4));
14426                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14428                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14431                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14432                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14434                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14435                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14436                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14437                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14441         }
14442         if (ndr_flags & NDR_BUFFERS) {
14443         }
14444         return NDR_ERR_SUCCESS;
14445 }
14446
14447 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
14448 {
14449         ndr_print_struct(ndr, name, "spoolss_PortData1");
14450         ndr->depth++;
14451         ndr_print_string(ndr, "portname", r->portname);
14452         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
14453         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14454         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14455         ndr_print_uint32(ndr, "reserved", r->reserved);
14456         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14457         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14458         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14459         ndr_print_string(ndr, "queue", r->queue);
14460         ndr_print_string(ndr, "ip_address", r->ip_address);
14461         ndr_print_string(ndr, "hardware_address", r->hardware_address);
14462         ndr_print_string(ndr, "device_type", r->device_type);
14463         ndr_print_uint32(ndr, "port_number", r->port_number);
14464         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14465         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14466         ndr->depth--;
14467 }
14468
14469 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
14470 {
14471         if (ndr_flags & NDR_SCALARS) {
14472                 NDR_CHECK(ndr_push_align(ndr, 4));
14473                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
14475                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14478                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14479                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14481                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14482                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
14487         }
14488         if (ndr_flags & NDR_BUFFERS) {
14489         }
14490         return NDR_ERR_SUCCESS;
14491 }
14492
14493 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
14494 {
14495         if (ndr_flags & NDR_SCALARS) {
14496                 NDR_CHECK(ndr_pull_align(ndr, 4));
14497                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14499                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14502                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14503                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14505                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14506                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
14511         }
14512         if (ndr_flags & NDR_BUFFERS) {
14513         }
14514         return NDR_ERR_SUCCESS;
14515 }
14516
14517 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
14518 {
14519         ndr_print_struct(ndr, name, "spoolss_PortData2");
14520         ndr->depth++;
14521         ndr_print_string(ndr, "portname", r->portname);
14522         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
14523         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14524         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14525         ndr_print_uint32(ndr, "reserved", r->reserved);
14526         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14527         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14528         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14529         ndr_print_string(ndr, "queue", r->queue);
14530         ndr_print_string(ndr, "device_type", r->device_type);
14531         ndr_print_uint32(ndr, "port_number", r->port_number);
14532         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14533         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14534         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
14535         ndr->depth--;
14536 }
14537
14538 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
14539 {
14540         if (ndr_flags & NDR_SCALARS) {
14541                 NDR_CHECK(ndr_push_align(ndr, 4));
14542                 {
14543                         uint32_t _flags_save_string = ndr->flags;
14544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14545                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
14546                         ndr->flags = _flags_save_string;
14547                 }
14548         }
14549         if (ndr_flags & NDR_BUFFERS) {
14550         }
14551         return NDR_ERR_SUCCESS;
14552 }
14553
14554 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
14555 {
14556         if (ndr_flags & NDR_SCALARS) {
14557                 NDR_CHECK(ndr_pull_align(ndr, 4));
14558                 {
14559                         uint32_t _flags_save_string = ndr->flags;
14560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14561                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
14562                         ndr->flags = _flags_save_string;
14563                 }
14564         }
14565         if (ndr_flags & NDR_BUFFERS) {
14566         }
14567         return NDR_ERR_SUCCESS;
14568 }
14569
14570 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
14571 {
14572         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
14573         ndr->depth++;
14574         ndr_print_string(ndr, "dll_name", r->dll_name);
14575         ndr->depth--;
14576 }
14577
14578 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14579 {
14580         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14581         return NDR_ERR_SUCCESS;
14582 }
14583
14584 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14585 {
14586         uint32_t v;
14587         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14588         *r = v;
14589         return NDR_ERR_SUCCESS;
14590 }
14591
14592 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14593 {
14594         ndr_print_uint32(ndr, name, r);
14595         ndr->depth++;
14596         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
14597         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
14598         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
14599         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
14600         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
14601         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
14602         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
14603         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
14604         ndr->depth--;
14605 }
14606
14607 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
14608 {
14609         if (flags & NDR_IN) {
14610                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
14611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14612                 if (r->in.server) {
14613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14616                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14617                 }
14618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14620                 if (r->in.buffer) {
14621                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14622                 }
14623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14624         }
14625         if (flags & NDR_OUT) {
14626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14627                 if (r->out.info) {
14628                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
14629                 }
14630                 if (r->out.needed == NULL) {
14631                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14632                 }
14633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14634                 if (r->out.count == NULL) {
14635                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14636                 }
14637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
14638                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14639         }
14640         return NDR_ERR_SUCCESS;
14641 }
14642
14643 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
14644 {
14645         uint32_t _ptr_server;
14646         uint32_t _ptr_buffer;
14647         uint32_t _ptr_info;
14648         TALLOC_CTX *_mem_save_server_0;
14649         TALLOC_CTX *_mem_save_buffer_0;
14650         TALLOC_CTX *_mem_save_info_0;
14651         TALLOC_CTX *_mem_save_needed_0;
14652         TALLOC_CTX *_mem_save_count_0;
14653         if (flags & NDR_IN) {
14654                 ZERO_STRUCT(r->out);
14655
14656                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
14657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14658                 if (_ptr_server) {
14659                         NDR_PULL_ALLOC(ndr, r->in.server);
14660                 } else {
14661                         r->in.server = NULL;
14662                 }
14663                 if (r->in.server) {
14664                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14665                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14668                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14669                                 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));
14670                         }
14671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14674                 }
14675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14677                 if (_ptr_buffer) {
14678                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14679                 } else {
14680                         r->in.buffer = NULL;
14681                 }
14682                 if (r->in.buffer) {
14683                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14684                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14685                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14687                 }
14688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14689                 NDR_PULL_ALLOC(ndr, r->out.needed);
14690                 ZERO_STRUCTP(r->out.needed);
14691                 NDR_PULL_ALLOC(ndr, r->out.count);
14692                 ZERO_STRUCTP(r->out.count);
14693         }
14694         if (flags & NDR_OUT) {
14695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14696                 if (_ptr_info) {
14697                         NDR_PULL_ALLOC(ndr, r->out.info);
14698                 } else {
14699                         r->out.info = NULL;
14700                 }
14701                 if (r->out.info) {
14702                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14703                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14704                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
14705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14706                 }
14707                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14708                         NDR_PULL_ALLOC(ndr, r->out.needed);
14709                 }
14710                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14711                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14713                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14714                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14715                         NDR_PULL_ALLOC(ndr, r->out.count);
14716                 }
14717                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
14718                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
14719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
14720                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
14721                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14722         }
14723         return NDR_ERR_SUCCESS;
14724 }
14725
14726 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
14727 {
14728         uint32_t cntr_info_0;
14729         if (flags & NDR_IN) {
14730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
14732         }
14733         if (flags & NDR_OUT) {
14734                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14735                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14736                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14737                 }
14738                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14739                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14740                 }
14741         }
14742         return NDR_ERR_SUCCESS;
14743 }
14744
14745 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
14746 {
14747         uint32_t cntr_info_0;
14748         TALLOC_CTX *_mem_save_info_0;
14749         if (flags & NDR_IN) {
14750                 ZERO_STRUCT(r->out);
14751
14752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
14754         }
14755         if (flags & NDR_OUT) {
14756                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
14757                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14758                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14759                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14760                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14761                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14762                 }
14763                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14764                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14765                 }
14766                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14767         }
14768         return NDR_ERR_SUCCESS;
14769 }
14770
14771 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
14772 {
14773         uint32_t cntr_info_1;
14774         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
14775         ndr->depth++;
14776         if (flags & NDR_SET_VALUES) {
14777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14778         }
14779         if (flags & NDR_IN) {
14780                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
14781                 ndr->depth++;
14782                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
14783                 ndr_print_ptr(ndr, "server", r->in.server);
14784                 ndr->depth++;
14785                 if (r->in.server) {
14786                         ndr_print_string(ndr, "server", r->in.server);
14787                 }
14788                 ndr->depth--;
14789                 ndr_print_uint32(ndr, "level", r->in.level);
14790                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14791                 ndr->depth++;
14792                 if (r->in.buffer) {
14793                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14794                 }
14795                 ndr->depth--;
14796                 ndr_print_uint32(ndr, "offered", r->in.offered);
14797                 ndr->depth--;
14798         }
14799         if (flags & NDR_OUT) {
14800                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
14801                 ndr->depth++;
14802                 ndr_print_ptr(ndr, "count", r->out.count);
14803                 ndr->depth++;
14804                 ndr_print_uint32(ndr, "count", *r->out.count);
14805                 ndr->depth--;
14806                 ndr_print_ptr(ndr, "info", r->out.info);
14807                 ndr->depth++;
14808                 if (r->out.info) {
14809                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
14810                         ndr->depth++;
14811                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
14812                                 char *idx_1=NULL;
14813                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
14814                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
14815                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
14816                                         free(idx_1);
14817                                 }
14818                         }
14819                         ndr->depth--;
14820                 }
14821                 ndr->depth--;
14822                 ndr_print_ptr(ndr, "needed", r->out.needed);
14823                 ndr->depth++;
14824                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14825                 ndr->depth--;
14826                 ndr_print_WERROR(ndr, "result", r->out.result);
14827                 ndr->depth--;
14828         }
14829         ndr->depth--;
14830 }
14831
14832 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
14833 {
14834         if (flags & NDR_IN) {
14835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
14836                 if (r->in.printername) {
14837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14838                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14840                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14841                 }
14842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
14843                 if (r->in.datatype) {
14844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14848                 }
14849                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14850                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
14851         }
14852         if (flags & NDR_OUT) {
14853                 if (r->out.handle == NULL) {
14854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14855                 }
14856                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14857                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14858         }
14859         return NDR_ERR_SUCCESS;
14860 }
14861
14862 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
14863 {
14864         uint32_t _ptr_printername;
14865         uint32_t _ptr_datatype;
14866         TALLOC_CTX *_mem_save_printername_0;
14867         TALLOC_CTX *_mem_save_datatype_0;
14868         TALLOC_CTX *_mem_save_handle_0;
14869         if (flags & NDR_IN) {
14870                 ZERO_STRUCT(r->out);
14871
14872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
14873                 if (_ptr_printername) {
14874                         NDR_PULL_ALLOC(ndr, r->in.printername);
14875                 } else {
14876                         r->in.printername = NULL;
14877                 }
14878                 if (r->in.printername) {
14879                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
14880                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
14881                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
14882                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
14883                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
14884                                 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));
14885                         }
14886                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
14887                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
14888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
14889                 }
14890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14891                 if (_ptr_datatype) {
14892                         NDR_PULL_ALLOC(ndr, r->in.datatype);
14893                 } else {
14894                         r->in.datatype = NULL;
14895                 }
14896                 if (r->in.datatype) {
14897                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14898                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
14899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
14900                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
14901                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
14902                                 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));
14903                         }
14904                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
14905                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
14906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14907                 }
14908                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14909                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
14910                 NDR_PULL_ALLOC(ndr, r->out.handle);
14911                 ZERO_STRUCTP(r->out.handle);
14912         }
14913         if (flags & NDR_OUT) {
14914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14915                         NDR_PULL_ALLOC(ndr, r->out.handle);
14916                 }
14917                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14918                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14919                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14921                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14922         }
14923         return NDR_ERR_SUCCESS;
14924 }
14925
14926 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
14927 {
14928         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
14929         ndr->depth++;
14930         if (flags & NDR_SET_VALUES) {
14931                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14932         }
14933         if (flags & NDR_IN) {
14934                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
14935                 ndr->depth++;
14936                 ndr_print_ptr(ndr, "printername", r->in.printername);
14937                 ndr->depth++;
14938                 if (r->in.printername) {
14939                         ndr_print_string(ndr, "printername", r->in.printername);
14940                 }
14941                 ndr->depth--;
14942                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
14943                 ndr->depth++;
14944                 if (r->in.datatype) {
14945                         ndr_print_string(ndr, "datatype", r->in.datatype);
14946                 }
14947                 ndr->depth--;
14948                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
14949                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
14950                 ndr->depth--;
14951         }
14952         if (flags & NDR_OUT) {
14953                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
14954                 ndr->depth++;
14955                 ndr_print_ptr(ndr, "handle", r->out.handle);
14956                 ndr->depth++;
14957                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14958                 ndr->depth--;
14959                 ndr_print_WERROR(ndr, "result", r->out.result);
14960                 ndr->depth--;
14961         }
14962         ndr->depth--;
14963 }
14964
14965 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
14966 {
14967         if (flags & NDR_IN) {
14968                 if (r->in.handle == NULL) {
14969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14970                 }
14971                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
14973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
14974                 if (r->in.ctr) {
14975                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14976                 }
14977                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
14978         }
14979         if (flags & NDR_OUT) {
14980                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14981         }
14982         return NDR_ERR_SUCCESS;
14983 }
14984
14985 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
14986 {
14987         uint32_t _ptr_ctr;
14988         TALLOC_CTX *_mem_save_handle_0;
14989         TALLOC_CTX *_mem_save_ctr_0;
14990         if (flags & NDR_IN) {
14991                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14992                         NDR_PULL_ALLOC(ndr, r->in.handle);
14993                 }
14994                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14995                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14996                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14997                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
14999                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
15000                 if (_ptr_ctr) {
15001                         NDR_PULL_ALLOC(ndr, r->in.ctr);
15002                 } else {
15003                         r->in.ctr = NULL;
15004                 }
15005                 if (r->in.ctr) {
15006                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15007                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
15008                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
15009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
15010                 }
15011                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
15012         }
15013         if (flags & NDR_OUT) {
15014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15015         }
15016         return NDR_ERR_SUCCESS;
15017 }
15018
15019 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
15020 {
15021         ndr_print_struct(ndr, name, "spoolss_SetJob");
15022         ndr->depth++;
15023         if (flags & NDR_SET_VALUES) {
15024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15025         }
15026         if (flags & NDR_IN) {
15027                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
15028                 ndr->depth++;
15029                 ndr_print_ptr(ndr, "handle", r->in.handle);
15030                 ndr->depth++;
15031                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15032                 ndr->depth--;
15033                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15034                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
15035                 ndr->depth++;
15036                 if (r->in.ctr) {
15037                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
15038                 }
15039                 ndr->depth--;
15040                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
15041                 ndr->depth--;
15042         }
15043         if (flags & NDR_OUT) {
15044                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
15045                 ndr->depth++;
15046                 ndr_print_WERROR(ndr, "result", r->out.result);
15047                 ndr->depth--;
15048         }
15049         ndr->depth--;
15050 }
15051
15052 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
15053 {
15054         if (flags & NDR_IN) {
15055                 if (r->in.handle == NULL) {
15056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15057                 }
15058                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
15060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15062                 if (r->in.buffer) {
15063                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15064                 }
15065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15066         }
15067         if (flags & NDR_OUT) {
15068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15069                 if (r->out.info) {
15070                         {
15071                                 struct ndr_push *_ndr_info;
15072                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15073                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15074                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15075                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15076                         }
15077                 }
15078                 if (r->out.needed == NULL) {
15079                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15080                 }
15081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15082                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15083         }
15084         return NDR_ERR_SUCCESS;
15085 }
15086
15087 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
15088 {
15089         uint32_t _ptr_buffer;
15090         uint32_t _ptr_info;
15091         TALLOC_CTX *_mem_save_handle_0;
15092         TALLOC_CTX *_mem_save_buffer_0;
15093         TALLOC_CTX *_mem_save_info_0;
15094         TALLOC_CTX *_mem_save_needed_0;
15095         if (flags & NDR_IN) {
15096                 ZERO_STRUCT(r->out);
15097
15098                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15099                         NDR_PULL_ALLOC(ndr, r->in.handle);
15100                 }
15101                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15102                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15103                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15104                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
15106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15108                 if (_ptr_buffer) {
15109                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15110                 } else {
15111                         r->in.buffer = NULL;
15112                 }
15113                 if (r->in.buffer) {
15114                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15115                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15116                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15118                 }
15119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15120                 NDR_PULL_ALLOC(ndr, r->out.needed);
15121                 ZERO_STRUCTP(r->out.needed);
15122         }
15123         if (flags & NDR_OUT) {
15124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15125                 if (_ptr_info) {
15126                         NDR_PULL_ALLOC(ndr, r->out.info);
15127                 } else {
15128                         r->out.info = NULL;
15129                 }
15130                 if (r->out.info) {
15131                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15132                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15133                         {
15134                                 struct ndr_pull *_ndr_info;
15135                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15136                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15137                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15138                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15139                         }
15140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15141                 }
15142                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15143                         NDR_PULL_ALLOC(ndr, r->out.needed);
15144                 }
15145                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15146                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15148                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15149                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15150         }
15151         return NDR_ERR_SUCCESS;
15152 }
15153
15154 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
15155 {
15156         ndr_print_struct(ndr, name, "spoolss_GetJob");
15157         ndr->depth++;
15158         if (flags & NDR_SET_VALUES) {
15159                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15160         }
15161         if (flags & NDR_IN) {
15162                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
15163                 ndr->depth++;
15164                 ndr_print_ptr(ndr, "handle", r->in.handle);
15165                 ndr->depth++;
15166                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15167                 ndr->depth--;
15168                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15169                 ndr_print_uint32(ndr, "level", r->in.level);
15170                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15171                 ndr->depth++;
15172                 if (r->in.buffer) {
15173                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15174                 }
15175                 ndr->depth--;
15176                 ndr_print_uint32(ndr, "offered", r->in.offered);
15177                 ndr->depth--;
15178         }
15179         if (flags & NDR_OUT) {
15180                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
15181                 ndr->depth++;
15182                 ndr_print_ptr(ndr, "info", r->out.info);
15183                 ndr->depth++;
15184                 if (r->out.info) {
15185                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15186                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
15187                 }
15188                 ndr->depth--;
15189                 ndr_print_ptr(ndr, "needed", r->out.needed);
15190                 ndr->depth++;
15191                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15192                 ndr->depth--;
15193                 ndr_print_WERROR(ndr, "result", r->out.result);
15194                 ndr->depth--;
15195         }
15196         ndr->depth--;
15197 }
15198
15199 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
15200 {
15201         if (flags & NDR_IN) {
15202                 if (r->in.handle == NULL) {
15203                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15204                 }
15205                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
15207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
15208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15209                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15210                 if (r->in.buffer) {
15211                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15212                 }
15213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15214         }
15215         if (flags & NDR_OUT) {
15216                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15217                 if (r->out.info) {
15218                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15219                 }
15220                 if (r->out.needed == NULL) {
15221                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15222                 }
15223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15224                 if (r->out.count == NULL) {
15225                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15226                 }
15227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15228                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15229         }
15230         return NDR_ERR_SUCCESS;
15231 }
15232
15233 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
15234 {
15235         uint32_t _ptr_buffer;
15236         uint32_t _ptr_info;
15237         TALLOC_CTX *_mem_save_handle_0;
15238         TALLOC_CTX *_mem_save_buffer_0;
15239         TALLOC_CTX *_mem_save_info_0;
15240         TALLOC_CTX *_mem_save_needed_0;
15241         TALLOC_CTX *_mem_save_count_0;
15242         if (flags & NDR_IN) {
15243                 ZERO_STRUCT(r->out);
15244
15245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15246                         NDR_PULL_ALLOC(ndr, r->in.handle);
15247                 }
15248                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15249                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
15253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
15254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15255                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15256                 if (_ptr_buffer) {
15257                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15258                 } else {
15259                         r->in.buffer = NULL;
15260                 }
15261                 if (r->in.buffer) {
15262                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15263                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15264                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15265                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15266                 }
15267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15268                 NDR_PULL_ALLOC(ndr, r->out.needed);
15269                 ZERO_STRUCTP(r->out.needed);
15270                 NDR_PULL_ALLOC(ndr, r->out.count);
15271                 ZERO_STRUCTP(r->out.count);
15272         }
15273         if (flags & NDR_OUT) {
15274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15275                 if (_ptr_info) {
15276                         NDR_PULL_ALLOC(ndr, r->out.info);
15277                 } else {
15278                         r->out.info = NULL;
15279                 }
15280                 if (r->out.info) {
15281                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15282                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15283                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15285                 }
15286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15287                         NDR_PULL_ALLOC(ndr, r->out.needed);
15288                 }
15289                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15290                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15293                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15294                         NDR_PULL_ALLOC(ndr, r->out.count);
15295                 }
15296                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15297                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15299                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15300                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15301         }
15302         return NDR_ERR_SUCCESS;
15303 }
15304
15305 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
15306 {
15307         uint32_t cntr_info_0;
15308         if (flags & NDR_IN) {
15309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15311         }
15312         if (flags & NDR_OUT) {
15313                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15314                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15315                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15316                 }
15317                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15318                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15319                 }
15320         }
15321         return NDR_ERR_SUCCESS;
15322 }
15323
15324 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
15325 {
15326         uint32_t cntr_info_0;
15327         TALLOC_CTX *_mem_save_info_0;
15328         if (flags & NDR_IN) {
15329                 ZERO_STRUCT(r->out);
15330
15331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15333         }
15334         if (flags & NDR_OUT) {
15335                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15336                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15337                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15338                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15339                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15340                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15341                 }
15342                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15343                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15344                 }
15345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15346         }
15347         return NDR_ERR_SUCCESS;
15348 }
15349
15350 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
15351 {
15352         uint32_t cntr_info_1;
15353         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
15354         ndr->depth++;
15355         if (flags & NDR_SET_VALUES) {
15356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15357         }
15358         if (flags & NDR_IN) {
15359                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
15360                 ndr->depth++;
15361                 ndr_print_ptr(ndr, "handle", r->in.handle);
15362                 ndr->depth++;
15363                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15364                 ndr->depth--;
15365                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
15366                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
15367                 ndr_print_uint32(ndr, "level", r->in.level);
15368                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15369                 ndr->depth++;
15370                 if (r->in.buffer) {
15371                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15372                 }
15373                 ndr->depth--;
15374                 ndr_print_uint32(ndr, "offered", r->in.offered);
15375                 ndr->depth--;
15376         }
15377         if (flags & NDR_OUT) {
15378                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
15379                 ndr->depth++;
15380                 ndr_print_ptr(ndr, "count", r->out.count);
15381                 ndr->depth++;
15382                 ndr_print_uint32(ndr, "count", *r->out.count);
15383                 ndr->depth--;
15384                 ndr_print_ptr(ndr, "info", r->out.info);
15385                 ndr->depth++;
15386                 if (r->out.info) {
15387                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15388                         ndr->depth++;
15389                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15390                                 char *idx_1=NULL;
15391                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15392                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15393                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
15394                                         free(idx_1);
15395                                 }
15396                         }
15397                         ndr->depth--;
15398                 }
15399                 ndr->depth--;
15400                 ndr_print_ptr(ndr, "needed", r->out.needed);
15401                 ndr->depth++;
15402                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15403                 ndr->depth--;
15404                 ndr_print_WERROR(ndr, "result", r->out.result);
15405                 ndr->depth--;
15406         }
15407         ndr->depth--;
15408 }
15409
15410 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
15411 {
15412         if (flags & NDR_IN) {
15413         }
15414         if (flags & NDR_OUT) {
15415                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15416         }
15417         return NDR_ERR_SUCCESS;
15418 }
15419
15420 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
15421 {
15422         if (flags & NDR_IN) {
15423         }
15424         if (flags & NDR_OUT) {
15425                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15426         }
15427         return NDR_ERR_SUCCESS;
15428 }
15429
15430 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
15431 {
15432         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
15433         ndr->depth++;
15434         if (flags & NDR_SET_VALUES) {
15435                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15436         }
15437         if (flags & NDR_IN) {
15438                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
15439                 ndr->depth++;
15440                 ndr->depth--;
15441         }
15442         if (flags & NDR_OUT) {
15443                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
15444                 ndr->depth++;
15445                 ndr_print_WERROR(ndr, "result", r->out.result);
15446                 ndr->depth--;
15447         }
15448         ndr->depth--;
15449 }
15450
15451 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
15452 {
15453         if (flags & NDR_IN) {
15454                 if (r->in.handle == NULL) {
15455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15456                 }
15457                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15458         }
15459         if (flags & NDR_OUT) {
15460                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15461         }
15462         return NDR_ERR_SUCCESS;
15463 }
15464
15465 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
15466 {
15467         TALLOC_CTX *_mem_save_handle_0;
15468         if (flags & NDR_IN) {
15469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15470                         NDR_PULL_ALLOC(ndr, r->in.handle);
15471                 }
15472                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15473                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15474                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15476         }
15477         if (flags & NDR_OUT) {
15478                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15479         }
15480         return NDR_ERR_SUCCESS;
15481 }
15482
15483 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
15484 {
15485         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
15486         ndr->depth++;
15487         if (flags & NDR_SET_VALUES) {
15488                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15489         }
15490         if (flags & NDR_IN) {
15491                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
15492                 ndr->depth++;
15493                 ndr_print_ptr(ndr, "handle", r->in.handle);
15494                 ndr->depth++;
15495                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15496                 ndr->depth--;
15497                 ndr->depth--;
15498         }
15499         if (flags & NDR_OUT) {
15500                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
15501                 ndr->depth++;
15502                 ndr_print_WERROR(ndr, "result", r->out.result);
15503                 ndr->depth--;
15504         }
15505         ndr->depth--;
15506 }
15507
15508 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
15509 {
15510         if (flags & NDR_IN) {
15511                 if (r->in.handle == NULL) {
15512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15513                 }
15514                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15515                 if (r->in.info_ctr == NULL) {
15516                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15517                 }
15518                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15519                 if (r->in.devmode_ctr == NULL) {
15520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15521                 }
15522                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15523                 if (r->in.secdesc_ctr == NULL) {
15524                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15525                 }
15526                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15527                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
15528         }
15529         if (flags & NDR_OUT) {
15530                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15531         }
15532         return NDR_ERR_SUCCESS;
15533 }
15534
15535 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
15536 {
15537         TALLOC_CTX *_mem_save_handle_0;
15538         TALLOC_CTX *_mem_save_info_ctr_0;
15539         TALLOC_CTX *_mem_save_devmode_ctr_0;
15540         TALLOC_CTX *_mem_save_secdesc_ctr_0;
15541         if (flags & NDR_IN) {
15542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15543                         NDR_PULL_ALLOC(ndr, r->in.handle);
15544                 }
15545                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15546                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15547                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15550                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15551                 }
15552                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15553                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15554                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15556                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15557                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
15558                 }
15559                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15560                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
15561                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15562                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15564                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
15565                 }
15566                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15567                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
15568                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15570                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
15571         }
15572         if (flags & NDR_OUT) {
15573                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15574         }
15575         return NDR_ERR_SUCCESS;
15576 }
15577
15578 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
15579 {
15580         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
15581         ndr->depth++;
15582         if (flags & NDR_SET_VALUES) {
15583                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15584         }
15585         if (flags & NDR_IN) {
15586                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
15587                 ndr->depth++;
15588                 ndr_print_ptr(ndr, "handle", r->in.handle);
15589                 ndr->depth++;
15590                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15591                 ndr->depth--;
15592                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15593                 ndr->depth++;
15594                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15595                 ndr->depth--;
15596                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
15597                 ndr->depth++;
15598                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
15599                 ndr->depth--;
15600                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15601                 ndr->depth++;
15602                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15603                 ndr->depth--;
15604                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
15605                 ndr->depth--;
15606         }
15607         if (flags & NDR_OUT) {
15608                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
15609                 ndr->depth++;
15610                 ndr_print_WERROR(ndr, "result", r->out.result);
15611                 ndr->depth--;
15612         }
15613         ndr->depth--;
15614 }
15615
15616 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
15617 {
15618         if (flags & NDR_IN) {
15619                 if (r->in.handle == NULL) {
15620                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15621                 }
15622                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15625                 if (r->in.buffer) {
15626                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15627                 }
15628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15629         }
15630         if (flags & NDR_OUT) {
15631                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15632                 if (r->out.info) {
15633                         {
15634                                 struct ndr_push *_ndr_info;
15635                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15636                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15637                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15638                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15639                         }
15640                 }
15641                 if (r->out.needed == NULL) {
15642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15643                 }
15644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15645                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15646         }
15647         return NDR_ERR_SUCCESS;
15648 }
15649
15650 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
15651 {
15652         uint32_t _ptr_buffer;
15653         uint32_t _ptr_info;
15654         TALLOC_CTX *_mem_save_handle_0;
15655         TALLOC_CTX *_mem_save_buffer_0;
15656         TALLOC_CTX *_mem_save_info_0;
15657         TALLOC_CTX *_mem_save_needed_0;
15658         if (flags & NDR_IN) {
15659                 ZERO_STRUCT(r->out);
15660
15661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15662                         NDR_PULL_ALLOC(ndr, r->in.handle);
15663                 }
15664                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15665                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15666                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15669                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15670                 if (_ptr_buffer) {
15671                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15672                 } else {
15673                         r->in.buffer = NULL;
15674                 }
15675                 if (r->in.buffer) {
15676                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15677                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15678                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15680                 }
15681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15682                 NDR_PULL_ALLOC(ndr, r->out.needed);
15683                 ZERO_STRUCTP(r->out.needed);
15684         }
15685         if (flags & NDR_OUT) {
15686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15687                 if (_ptr_info) {
15688                         NDR_PULL_ALLOC(ndr, r->out.info);
15689                 } else {
15690                         r->out.info = NULL;
15691                 }
15692                 if (r->out.info) {
15693                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15694                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15695                         {
15696                                 struct ndr_pull *_ndr_info;
15697                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15698                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15699                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15700                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15701                         }
15702                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15703                 }
15704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15705                         NDR_PULL_ALLOC(ndr, r->out.needed);
15706                 }
15707                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15711                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15712         }
15713         return NDR_ERR_SUCCESS;
15714 }
15715
15716 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
15717 {
15718         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
15719         ndr->depth++;
15720         if (flags & NDR_SET_VALUES) {
15721                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15722         }
15723         if (flags & NDR_IN) {
15724                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
15725                 ndr->depth++;
15726                 ndr_print_ptr(ndr, "handle", r->in.handle);
15727                 ndr->depth++;
15728                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15729                 ndr->depth--;
15730                 ndr_print_uint32(ndr, "level", r->in.level);
15731                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15732                 ndr->depth++;
15733                 if (r->in.buffer) {
15734                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15735                 }
15736                 ndr->depth--;
15737                 ndr_print_uint32(ndr, "offered", r->in.offered);
15738                 ndr->depth--;
15739         }
15740         if (flags & NDR_OUT) {
15741                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
15742                 ndr->depth++;
15743                 ndr_print_ptr(ndr, "info", r->out.info);
15744                 ndr->depth++;
15745                 if (r->out.info) {
15746                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15747                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
15748                 }
15749                 ndr->depth--;
15750                 ndr_print_ptr(ndr, "needed", r->out.needed);
15751                 ndr->depth++;
15752                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15753                 ndr->depth--;
15754                 ndr_print_WERROR(ndr, "result", r->out.result);
15755                 ndr->depth--;
15756         }
15757         ndr->depth--;
15758 }
15759
15760 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
15761 {
15762         if (flags & NDR_IN) {
15763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
15764                 if (r->in.servername) {
15765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15768                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15769                 }
15770                 if (r->in.info_ctr == NULL) {
15771                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15772                 }
15773                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15774         }
15775         if (flags & NDR_OUT) {
15776                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15777         }
15778         return NDR_ERR_SUCCESS;
15779 }
15780
15781 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
15782 {
15783         uint32_t _ptr_servername;
15784         TALLOC_CTX *_mem_save_servername_0;
15785         TALLOC_CTX *_mem_save_info_ctr_0;
15786         if (flags & NDR_IN) {
15787                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
15788                 if (_ptr_servername) {
15789                         NDR_PULL_ALLOC(ndr, r->in.servername);
15790                 } else {
15791                         r->in.servername = NULL;
15792                 }
15793                 if (r->in.servername) {
15794                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
15795                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
15796                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
15797                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
15798                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
15799                                 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));
15800                         }
15801                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
15802                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
15803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
15804                 }
15805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15806                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15807                 }
15808                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15809                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15810                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15812         }
15813         if (flags & NDR_OUT) {
15814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15815         }
15816         return NDR_ERR_SUCCESS;
15817 }
15818
15819 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
15820 {
15821         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
15822         ndr->depth++;
15823         if (flags & NDR_SET_VALUES) {
15824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15825         }
15826         if (flags & NDR_IN) {
15827                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
15828                 ndr->depth++;
15829                 ndr_print_ptr(ndr, "servername", r->in.servername);
15830                 ndr->depth++;
15831                 if (r->in.servername) {
15832                         ndr_print_string(ndr, "servername", r->in.servername);
15833                 }
15834                 ndr->depth--;
15835                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15836                 ndr->depth++;
15837                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15838                 ndr->depth--;
15839                 ndr->depth--;
15840         }
15841         if (flags & NDR_OUT) {
15842                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
15843                 ndr->depth++;
15844                 ndr_print_WERROR(ndr, "result", r->out.result);
15845                 ndr->depth--;
15846         }
15847         ndr->depth--;
15848 }
15849
15850 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
15851 {
15852         if (flags & NDR_IN) {
15853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15854                 if (r->in.server) {
15855                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15858                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15859                 }
15860                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
15861                 if (r->in.environment) {
15862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15866                 }
15867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15869                 if (r->in.buffer) {
15870                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15871                 }
15872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15873         }
15874         if (flags & NDR_OUT) {
15875                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15876                 if (r->out.info) {
15877                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15878                 }
15879                 if (r->out.needed == NULL) {
15880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15881                 }
15882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15883                 if (r->out.count == NULL) {
15884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15885                 }
15886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15888         }
15889         return NDR_ERR_SUCCESS;
15890 }
15891
15892 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
15893 {
15894         uint32_t _ptr_server;
15895         uint32_t _ptr_environment;
15896         uint32_t _ptr_buffer;
15897         uint32_t _ptr_info;
15898         TALLOC_CTX *_mem_save_server_0;
15899         TALLOC_CTX *_mem_save_environment_0;
15900         TALLOC_CTX *_mem_save_buffer_0;
15901         TALLOC_CTX *_mem_save_info_0;
15902         TALLOC_CTX *_mem_save_needed_0;
15903         TALLOC_CTX *_mem_save_count_0;
15904         if (flags & NDR_IN) {
15905                 ZERO_STRUCT(r->out);
15906
15907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15908                 if (_ptr_server) {
15909                         NDR_PULL_ALLOC(ndr, r->in.server);
15910                 } else {
15911                         r->in.server = NULL;
15912                 }
15913                 if (r->in.server) {
15914                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15915                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15916                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15917                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15918                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15919                                 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));
15920                         }
15921                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15922                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15924                 }
15925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
15926                 if (_ptr_environment) {
15927                         NDR_PULL_ALLOC(ndr, r->in.environment);
15928                 } else {
15929                         r->in.environment = NULL;
15930                 }
15931                 if (r->in.environment) {
15932                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
15933                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
15934                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
15935                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
15936                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
15937                                 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));
15938                         }
15939                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
15940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
15941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
15942                 }
15943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15945                 if (_ptr_buffer) {
15946                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15947                 } else {
15948                         r->in.buffer = NULL;
15949                 }
15950                 if (r->in.buffer) {
15951                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15952                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15953                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15955                 }
15956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15957                 NDR_PULL_ALLOC(ndr, r->out.needed);
15958                 ZERO_STRUCTP(r->out.needed);
15959                 NDR_PULL_ALLOC(ndr, r->out.count);
15960                 ZERO_STRUCTP(r->out.count);
15961         }
15962         if (flags & NDR_OUT) {
15963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15964                 if (_ptr_info) {
15965                         NDR_PULL_ALLOC(ndr, r->out.info);
15966                 } else {
15967                         r->out.info = NULL;
15968                 }
15969                 if (r->out.info) {
15970                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15971                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15972                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15974                 }
15975                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15976                         NDR_PULL_ALLOC(ndr, r->out.needed);
15977                 }
15978                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15979                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15982                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15983                         NDR_PULL_ALLOC(ndr, r->out.count);
15984                 }
15985                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15986                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15989                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15990         }
15991         return NDR_ERR_SUCCESS;
15992 }
15993
15994 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
15995 {
15996         uint32_t cntr_info_0;
15997         if (flags & NDR_IN) {
15998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16000         }
16001         if (flags & NDR_OUT) {
16002                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16003                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16004                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16005                 }
16006                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16007                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16008                 }
16009         }
16010         return NDR_ERR_SUCCESS;
16011 }
16012
16013 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
16014 {
16015         uint32_t cntr_info_0;
16016         TALLOC_CTX *_mem_save_info_0;
16017         if (flags & NDR_IN) {
16018                 ZERO_STRUCT(r->out);
16019
16020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16022         }
16023         if (flags & NDR_OUT) {
16024                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16025                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16026                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16027                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16028                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16029                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16030                 }
16031                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16032                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16033                 }
16034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16035         }
16036         return NDR_ERR_SUCCESS;
16037 }
16038
16039 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
16040 {
16041         uint32_t cntr_info_1;
16042         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
16043         ndr->depth++;
16044         if (flags & NDR_SET_VALUES) {
16045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16046         }
16047         if (flags & NDR_IN) {
16048                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
16049                 ndr->depth++;
16050                 ndr_print_ptr(ndr, "server", r->in.server);
16051                 ndr->depth++;
16052                 if (r->in.server) {
16053                         ndr_print_string(ndr, "server", r->in.server);
16054                 }
16055                 ndr->depth--;
16056                 ndr_print_ptr(ndr, "environment", r->in.environment);
16057                 ndr->depth++;
16058                 if (r->in.environment) {
16059                         ndr_print_string(ndr, "environment", r->in.environment);
16060                 }
16061                 ndr->depth--;
16062                 ndr_print_uint32(ndr, "level", r->in.level);
16063                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16064                 ndr->depth++;
16065                 if (r->in.buffer) {
16066                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16067                 }
16068                 ndr->depth--;
16069                 ndr_print_uint32(ndr, "offered", r->in.offered);
16070                 ndr->depth--;
16071         }
16072         if (flags & NDR_OUT) {
16073                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
16074                 ndr->depth++;
16075                 ndr_print_ptr(ndr, "count", r->out.count);
16076                 ndr->depth++;
16077                 ndr_print_uint32(ndr, "count", *r->out.count);
16078                 ndr->depth--;
16079                 ndr_print_ptr(ndr, "info", r->out.info);
16080                 ndr->depth++;
16081                 if (r->out.info) {
16082                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16083                         ndr->depth++;
16084                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16085                                 char *idx_1=NULL;
16086                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16087                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16088                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
16089                                         free(idx_1);
16090                                 }
16091                         }
16092                         ndr->depth--;
16093                 }
16094                 ndr->depth--;
16095                 ndr_print_ptr(ndr, "needed", r->out.needed);
16096                 ndr->depth++;
16097                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16098                 ndr->depth--;
16099                 ndr_print_WERROR(ndr, "result", r->out.result);
16100                 ndr->depth--;
16101         }
16102         ndr->depth--;
16103 }
16104
16105 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
16106 {
16107         if (flags & NDR_IN) {
16108         }
16109         if (flags & NDR_OUT) {
16110                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16111         }
16112         return NDR_ERR_SUCCESS;
16113 }
16114
16115 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
16116 {
16117         if (flags & NDR_IN) {
16118         }
16119         if (flags & NDR_OUT) {
16120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16121         }
16122         return NDR_ERR_SUCCESS;
16123 }
16124
16125 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
16126 {
16127         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
16128         ndr->depth++;
16129         if (flags & NDR_SET_VALUES) {
16130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16131         }
16132         if (flags & NDR_IN) {
16133                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
16134                 ndr->depth++;
16135                 ndr->depth--;
16136         }
16137         if (flags & NDR_OUT) {
16138                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
16139                 ndr->depth++;
16140                 ndr_print_WERROR(ndr, "result", r->out.result);
16141                 ndr->depth--;
16142         }
16143         ndr->depth--;
16144 }
16145
16146 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16147 {
16148         if (flags & NDR_IN) {
16149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16150                 if (r->in.server) {
16151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16154                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16155                 }
16156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16157                 if (r->in.environment) {
16158                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16159                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16160                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16161                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16162                 }
16163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16165                 if (r->in.buffer) {
16166                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16167                 }
16168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16169         }
16170         if (flags & NDR_OUT) {
16171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16172                 if (r->out.info) {
16173                         {
16174                                 struct ndr_push *_ndr_info;
16175                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16176                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16177                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16178                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16179                         }
16180                 }
16181                 if (r->out.needed == NULL) {
16182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16183                 }
16184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16185                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16186         }
16187         return NDR_ERR_SUCCESS;
16188 }
16189
16190 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
16191 {
16192         uint32_t _ptr_server;
16193         uint32_t _ptr_environment;
16194         uint32_t _ptr_buffer;
16195         uint32_t _ptr_info;
16196         TALLOC_CTX *_mem_save_server_0;
16197         TALLOC_CTX *_mem_save_environment_0;
16198         TALLOC_CTX *_mem_save_buffer_0;
16199         TALLOC_CTX *_mem_save_info_0;
16200         TALLOC_CTX *_mem_save_needed_0;
16201         if (flags & NDR_IN) {
16202                 ZERO_STRUCT(r->out);
16203
16204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16205                 if (_ptr_server) {
16206                         NDR_PULL_ALLOC(ndr, r->in.server);
16207                 } else {
16208                         r->in.server = NULL;
16209                 }
16210                 if (r->in.server) {
16211                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16212                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16214                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16215                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16216                                 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));
16217                         }
16218                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16221                 }
16222                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16223                 if (_ptr_environment) {
16224                         NDR_PULL_ALLOC(ndr, r->in.environment);
16225                 } else {
16226                         r->in.environment = NULL;
16227                 }
16228                 if (r->in.environment) {
16229                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16230                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16231                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16232                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16233                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16234                                 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));
16235                         }
16236                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16237                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16239                 }
16240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16242                 if (_ptr_buffer) {
16243                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16244                 } else {
16245                         r->in.buffer = NULL;
16246                 }
16247                 if (r->in.buffer) {
16248                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16250                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16252                 }
16253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16254                 NDR_PULL_ALLOC(ndr, r->out.needed);
16255                 ZERO_STRUCTP(r->out.needed);
16256         }
16257         if (flags & NDR_OUT) {
16258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16259                 if (_ptr_info) {
16260                         NDR_PULL_ALLOC(ndr, r->out.info);
16261                 } else {
16262                         r->out.info = NULL;
16263                 }
16264                 if (r->out.info) {
16265                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16266                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16267                         {
16268                                 struct ndr_pull *_ndr_info;
16269                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16270                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16271                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16272                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16273                         }
16274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16275                 }
16276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16277                         NDR_PULL_ALLOC(ndr, r->out.needed);
16278                 }
16279                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16280                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16283                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16284         }
16285         return NDR_ERR_SUCCESS;
16286 }
16287
16288 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16289 {
16290         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
16291         ndr->depth++;
16292         if (flags & NDR_SET_VALUES) {
16293                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16294         }
16295         if (flags & NDR_IN) {
16296                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
16297                 ndr->depth++;
16298                 ndr_print_ptr(ndr, "server", r->in.server);
16299                 ndr->depth++;
16300                 if (r->in.server) {
16301                         ndr_print_string(ndr, "server", r->in.server);
16302                 }
16303                 ndr->depth--;
16304                 ndr_print_ptr(ndr, "environment", r->in.environment);
16305                 ndr->depth++;
16306                 if (r->in.environment) {
16307                         ndr_print_string(ndr, "environment", r->in.environment);
16308                 }
16309                 ndr->depth--;
16310                 ndr_print_uint32(ndr, "level", r->in.level);
16311                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16312                 ndr->depth++;
16313                 if (r->in.buffer) {
16314                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16315                 }
16316                 ndr->depth--;
16317                 ndr_print_uint32(ndr, "offered", r->in.offered);
16318                 ndr->depth--;
16319         }
16320         if (flags & NDR_OUT) {
16321                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
16322                 ndr->depth++;
16323                 ndr_print_ptr(ndr, "info", r->out.info);
16324                 ndr->depth++;
16325                 if (r->out.info) {
16326                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16327                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
16328                 }
16329                 ndr->depth--;
16330                 ndr_print_ptr(ndr, "needed", r->out.needed);
16331                 ndr->depth++;
16332                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16333                 ndr->depth--;
16334                 ndr_print_WERROR(ndr, "result", r->out.result);
16335                 ndr->depth--;
16336         }
16337         ndr->depth--;
16338 }
16339
16340 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
16341 {
16342         if (flags & NDR_IN) {
16343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16344                 if (r->in.server) {
16345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16348                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16349                 }
16350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16353                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16357                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16358         }
16359         if (flags & NDR_OUT) {
16360                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16361         }
16362         return NDR_ERR_SUCCESS;
16363 }
16364
16365 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
16366 {
16367         uint32_t _ptr_server;
16368         TALLOC_CTX *_mem_save_server_0;
16369         if (flags & NDR_IN) {
16370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16371                 if (_ptr_server) {
16372                         NDR_PULL_ALLOC(ndr, r->in.server);
16373                 } else {
16374                         r->in.server = NULL;
16375                 }
16376                 if (r->in.server) {
16377                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16378                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16379                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16380                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16381                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16382                                 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));
16383                         }
16384                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16385                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16387                 }
16388                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16389                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16390                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16391                         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));
16392                 }
16393                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16394                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16395                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16396                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16397                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16398                         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));
16399                 }
16400                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16401                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16402         }
16403         if (flags & NDR_OUT) {
16404                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16405         }
16406         return NDR_ERR_SUCCESS;
16407 }
16408
16409 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
16410 {
16411         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
16412         ndr->depth++;
16413         if (flags & NDR_SET_VALUES) {
16414                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16415         }
16416         if (flags & NDR_IN) {
16417                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
16418                 ndr->depth++;
16419                 ndr_print_ptr(ndr, "server", r->in.server);
16420                 ndr->depth++;
16421                 if (r->in.server) {
16422                         ndr_print_string(ndr, "server", r->in.server);
16423                 }
16424                 ndr->depth--;
16425                 ndr_print_string(ndr, "architecture", r->in.architecture);
16426                 ndr_print_string(ndr, "driver", r->in.driver);
16427                 ndr->depth--;
16428         }
16429         if (flags & NDR_OUT) {
16430                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
16431                 ndr->depth++;
16432                 ndr_print_WERROR(ndr, "result", r->out.result);
16433                 ndr->depth--;
16434         }
16435         ndr->depth--;
16436 }
16437
16438 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
16439 {
16440         if (flags & NDR_IN) {
16441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16442                 if (r->in.server) {
16443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16447                 }
16448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16451                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16455                 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));
16456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16459                 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));
16460         }
16461         if (flags & NDR_OUT) {
16462                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16463         }
16464         return NDR_ERR_SUCCESS;
16465 }
16466
16467 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
16468 {
16469         uint32_t _ptr_server;
16470         TALLOC_CTX *_mem_save_server_0;
16471         if (flags & NDR_IN) {
16472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16473                 if (_ptr_server) {
16474                         NDR_PULL_ALLOC(ndr, r->in.server);
16475                 } else {
16476                         r->in.server = NULL;
16477                 }
16478                 if (r->in.server) {
16479                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16480                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16481                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16482                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16483                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16484                                 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));
16485                         }
16486                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16487                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16489                 }
16490                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16491                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16492                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16493                         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));
16494                 }
16495                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16496                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16497                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
16498                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
16499                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
16500                         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));
16501                 }
16502                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
16503                 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));
16504                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
16505                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
16506                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
16507                         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));
16508                 }
16509                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
16510                 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));
16511         }
16512         if (flags & NDR_OUT) {
16513                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16514         }
16515         return NDR_ERR_SUCCESS;
16516 }
16517
16518 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
16519 {
16520         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
16521         ndr->depth++;
16522         if (flags & NDR_SET_VALUES) {
16523                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16524         }
16525         if (flags & NDR_IN) {
16526                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
16527                 ndr->depth++;
16528                 ndr_print_ptr(ndr, "server", r->in.server);
16529                 ndr->depth++;
16530                 if (r->in.server) {
16531                         ndr_print_string(ndr, "server", r->in.server);
16532                 }
16533                 ndr->depth--;
16534                 ndr_print_string(ndr, "architecture", r->in.architecture);
16535                 ndr_print_string(ndr, "path_name", r->in.path_name);
16536                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
16537                 ndr->depth--;
16538         }
16539         if (flags & NDR_OUT) {
16540                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
16541                 ndr->depth++;
16542                 ndr_print_WERROR(ndr, "result", r->out.result);
16543                 ndr->depth--;
16544         }
16545         ndr->depth--;
16546 }
16547
16548 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
16549 {
16550         if (flags & NDR_IN) {
16551                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16552                 if (r->in.servername) {
16553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16555                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16556                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16557                 }
16558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16559                 if (r->in.environment) {
16560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16561                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16562                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16563                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16564                 }
16565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16566                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16567                 if (r->in.buffer) {
16568                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16569                 }
16570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16571         }
16572         if (flags & NDR_OUT) {
16573                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16574                 if (r->out.info) {
16575                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16576                 }
16577                 if (r->out.needed == NULL) {
16578                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16579                 }
16580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16581                 if (r->out.count == NULL) {
16582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16583                 }
16584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16585                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16586         }
16587         return NDR_ERR_SUCCESS;
16588 }
16589
16590 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
16591 {
16592         uint32_t _ptr_servername;
16593         uint32_t _ptr_environment;
16594         uint32_t _ptr_buffer;
16595         uint32_t _ptr_info;
16596         TALLOC_CTX *_mem_save_servername_0;
16597         TALLOC_CTX *_mem_save_environment_0;
16598         TALLOC_CTX *_mem_save_buffer_0;
16599         TALLOC_CTX *_mem_save_info_0;
16600         TALLOC_CTX *_mem_save_needed_0;
16601         TALLOC_CTX *_mem_save_count_0;
16602         if (flags & NDR_IN) {
16603                 ZERO_STRUCT(r->out);
16604
16605                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16606                 if (_ptr_servername) {
16607                         NDR_PULL_ALLOC(ndr, r->in.servername);
16608                 } else {
16609                         r->in.servername = NULL;
16610                 }
16611                 if (r->in.servername) {
16612                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16613                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16614                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16615                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16616                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16617                                 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));
16618                         }
16619                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16620                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16621                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16622                 }
16623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16624                 if (_ptr_environment) {
16625                         NDR_PULL_ALLOC(ndr, r->in.environment);
16626                 } else {
16627                         r->in.environment = NULL;
16628                 }
16629                 if (r->in.environment) {
16630                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16631                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16634                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16635                                 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));
16636                         }
16637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16640                 }
16641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16643                 if (_ptr_buffer) {
16644                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16645                 } else {
16646                         r->in.buffer = NULL;
16647                 }
16648                 if (r->in.buffer) {
16649                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16650                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16651                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16653                 }
16654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16655                 NDR_PULL_ALLOC(ndr, r->out.needed);
16656                 ZERO_STRUCTP(r->out.needed);
16657                 NDR_PULL_ALLOC(ndr, r->out.count);
16658                 ZERO_STRUCTP(r->out.count);
16659         }
16660         if (flags & NDR_OUT) {
16661                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16662                 if (_ptr_info) {
16663                         NDR_PULL_ALLOC(ndr, r->out.info);
16664                 } else {
16665                         r->out.info = NULL;
16666                 }
16667                 if (r->out.info) {
16668                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16669                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16670                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16672                 }
16673                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16674                         NDR_PULL_ALLOC(ndr, r->out.needed);
16675                 }
16676                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16677                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16679                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16680                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16681                         NDR_PULL_ALLOC(ndr, r->out.count);
16682                 }
16683                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16684                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16687                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16688         }
16689         return NDR_ERR_SUCCESS;
16690 }
16691
16692 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
16693 {
16694         uint32_t cntr_info_0;
16695         if (flags & NDR_IN) {
16696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16698         }
16699         if (flags & NDR_OUT) {
16700                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16701                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16702                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16703                 }
16704                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16705                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16706                 }
16707         }
16708         return NDR_ERR_SUCCESS;
16709 }
16710
16711 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
16712 {
16713         uint32_t cntr_info_0;
16714         TALLOC_CTX *_mem_save_info_0;
16715         if (flags & NDR_IN) {
16716                 ZERO_STRUCT(r->out);
16717
16718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16720         }
16721         if (flags & NDR_OUT) {
16722                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16723                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16724                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16725                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16726                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16727                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16728                 }
16729                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16730                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16731                 }
16732                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16733         }
16734         return NDR_ERR_SUCCESS;
16735 }
16736
16737 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
16738 {
16739         uint32_t cntr_info_1;
16740         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
16741         ndr->depth++;
16742         if (flags & NDR_SET_VALUES) {
16743                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16744         }
16745         if (flags & NDR_IN) {
16746                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
16747                 ndr->depth++;
16748                 ndr_print_ptr(ndr, "servername", r->in.servername);
16749                 ndr->depth++;
16750                 if (r->in.servername) {
16751                         ndr_print_string(ndr, "servername", r->in.servername);
16752                 }
16753                 ndr->depth--;
16754                 ndr_print_ptr(ndr, "environment", r->in.environment);
16755                 ndr->depth++;
16756                 if (r->in.environment) {
16757                         ndr_print_string(ndr, "environment", r->in.environment);
16758                 }
16759                 ndr->depth--;
16760                 ndr_print_uint32(ndr, "level", r->in.level);
16761                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16762                 ndr->depth++;
16763                 if (r->in.buffer) {
16764                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16765                 }
16766                 ndr->depth--;
16767                 ndr_print_uint32(ndr, "offered", r->in.offered);
16768                 ndr->depth--;
16769         }
16770         if (flags & NDR_OUT) {
16771                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
16772                 ndr->depth++;
16773                 ndr_print_ptr(ndr, "count", r->out.count);
16774                 ndr->depth++;
16775                 ndr_print_uint32(ndr, "count", *r->out.count);
16776                 ndr->depth--;
16777                 ndr_print_ptr(ndr, "info", r->out.info);
16778                 ndr->depth++;
16779                 if (r->out.info) {
16780                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16781                         ndr->depth++;
16782                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16783                                 char *idx_1=NULL;
16784                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16785                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16786                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
16787                                         free(idx_1);
16788                                 }
16789                         }
16790                         ndr->depth--;
16791                 }
16792                 ndr->depth--;
16793                 ndr_print_ptr(ndr, "needed", r->out.needed);
16794                 ndr->depth++;
16795                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16796                 ndr->depth--;
16797                 ndr_print_WERROR(ndr, "result", r->out.result);
16798                 ndr->depth--;
16799         }
16800         ndr->depth--;
16801 }
16802
16803 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16804 {
16805         if (flags & NDR_IN) {
16806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16807                 if (r->in.server) {
16808                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16809                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16810                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16811                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16812                 }
16813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16814                 if (r->in.environment) {
16815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16818                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16819                 }
16820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16821                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16822                 if (r->in.buffer) {
16823                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16824                 }
16825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16826         }
16827         if (flags & NDR_OUT) {
16828                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16829                 if (r->out.info) {
16830                         {
16831                                 struct ndr_push *_ndr_info;
16832                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16833                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16834                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16835                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16836                         }
16837                 }
16838                 if (r->out.needed == NULL) {
16839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16840                 }
16841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16842                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16843         }
16844         return NDR_ERR_SUCCESS;
16845 }
16846
16847 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
16848 {
16849         uint32_t _ptr_server;
16850         uint32_t _ptr_environment;
16851         uint32_t _ptr_buffer;
16852         uint32_t _ptr_info;
16853         TALLOC_CTX *_mem_save_server_0;
16854         TALLOC_CTX *_mem_save_environment_0;
16855         TALLOC_CTX *_mem_save_buffer_0;
16856         TALLOC_CTX *_mem_save_info_0;
16857         TALLOC_CTX *_mem_save_needed_0;
16858         if (flags & NDR_IN) {
16859                 ZERO_STRUCT(r->out);
16860
16861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16862                 if (_ptr_server) {
16863                         NDR_PULL_ALLOC(ndr, r->in.server);
16864                 } else {
16865                         r->in.server = NULL;
16866                 }
16867                 if (r->in.server) {
16868                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16869                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16870                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16871                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16872                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16873                                 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));
16874                         }
16875                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16876                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16878                 }
16879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16880                 if (_ptr_environment) {
16881                         NDR_PULL_ALLOC(ndr, r->in.environment);
16882                 } else {
16883                         r->in.environment = NULL;
16884                 }
16885                 if (r->in.environment) {
16886                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16887                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16889                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16890                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16891                                 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));
16892                         }
16893                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16894                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16896                 }
16897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16899                 if (_ptr_buffer) {
16900                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16901                 } else {
16902                         r->in.buffer = NULL;
16903                 }
16904                 if (r->in.buffer) {
16905                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16906                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16907                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16909                 }
16910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16911                 NDR_PULL_ALLOC(ndr, r->out.needed);
16912                 ZERO_STRUCTP(r->out.needed);
16913         }
16914         if (flags & NDR_OUT) {
16915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16916                 if (_ptr_info) {
16917                         NDR_PULL_ALLOC(ndr, r->out.info);
16918                 } else {
16919                         r->out.info = NULL;
16920                 }
16921                 if (r->out.info) {
16922                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16923                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16924                         {
16925                                 struct ndr_pull *_ndr_info;
16926                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16927                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16928                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16929                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16930                         }
16931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16932                 }
16933                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16934                         NDR_PULL_ALLOC(ndr, r->out.needed);
16935                 }
16936                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16937                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16939                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16940                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16941         }
16942         return NDR_ERR_SUCCESS;
16943 }
16944
16945 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16946 {
16947         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
16948         ndr->depth++;
16949         if (flags & NDR_SET_VALUES) {
16950                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16951         }
16952         if (flags & NDR_IN) {
16953                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
16954                 ndr->depth++;
16955                 ndr_print_ptr(ndr, "server", r->in.server);
16956                 ndr->depth++;
16957                 if (r->in.server) {
16958                         ndr_print_string(ndr, "server", r->in.server);
16959                 }
16960                 ndr->depth--;
16961                 ndr_print_ptr(ndr, "environment", r->in.environment);
16962                 ndr->depth++;
16963                 if (r->in.environment) {
16964                         ndr_print_string(ndr, "environment", r->in.environment);
16965                 }
16966                 ndr->depth--;
16967                 ndr_print_uint32(ndr, "level", r->in.level);
16968                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16969                 ndr->depth++;
16970                 if (r->in.buffer) {
16971                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16972                 }
16973                 ndr->depth--;
16974                 ndr_print_uint32(ndr, "offered", r->in.offered);
16975                 ndr->depth--;
16976         }
16977         if (flags & NDR_OUT) {
16978                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
16979                 ndr->depth++;
16980                 ndr_print_ptr(ndr, "info", r->out.info);
16981                 ndr->depth++;
16982                 if (r->out.info) {
16983                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16984                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
16985                 }
16986                 ndr->depth--;
16987                 ndr_print_ptr(ndr, "needed", r->out.needed);
16988                 ndr->depth++;
16989                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16990                 ndr->depth--;
16991                 ndr_print_WERROR(ndr, "result", r->out.result);
16992                 ndr->depth--;
16993         }
16994         ndr->depth--;
16995 }
16996
16997 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
16998 {
16999         if (flags & NDR_IN) {
17000                 if (r->in.handle == NULL) {
17001                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17002                 }
17003                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17005                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
17006                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17007         }
17008         if (flags & NDR_OUT) {
17009                 if (r->out.job_id == NULL) {
17010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17011                 }
17012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
17013                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17014         }
17015         return NDR_ERR_SUCCESS;
17016 }
17017
17018 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
17019 {
17020         TALLOC_CTX *_mem_save_handle_0;
17021         TALLOC_CTX *_mem_save_job_id_0;
17022         if (flags & NDR_IN) {
17023                 ZERO_STRUCT(r->out);
17024
17025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17026                         NDR_PULL_ALLOC(ndr, r->in.handle);
17027                 }
17028                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17029                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17030                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17033                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17034                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17035                 NDR_PULL_ALLOC(ndr, r->out.job_id);
17036                 ZERO_STRUCTP(r->out.job_id);
17037         }
17038         if (flags & NDR_OUT) {
17039                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17040                         NDR_PULL_ALLOC(ndr, r->out.job_id);
17041                 }
17042                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
17043                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
17044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
17045                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
17046                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17047         }
17048         return NDR_ERR_SUCCESS;
17049 }
17050
17051 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
17052 {
17053         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
17054         ndr->depth++;
17055         if (flags & NDR_SET_VALUES) {
17056                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17057         }
17058         if (flags & NDR_IN) {
17059                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
17060                 ndr->depth++;
17061                 ndr_print_ptr(ndr, "handle", r->in.handle);
17062                 ndr->depth++;
17063                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17064                 ndr->depth--;
17065                 ndr_print_uint32(ndr, "level", r->in.level);
17066                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
17067                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
17068                 ndr->depth--;
17069         }
17070         if (flags & NDR_OUT) {
17071                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
17072                 ndr->depth++;
17073                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
17074                 ndr->depth++;
17075                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
17076                 ndr->depth--;
17077                 ndr_print_WERROR(ndr, "result", r->out.result);
17078                 ndr->depth--;
17079         }
17080         ndr->depth--;
17081 }
17082
17083 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
17084 {
17085         if (flags & NDR_IN) {
17086                 if (r->in.handle == NULL) {
17087                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17088                 }
17089                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17090         }
17091         if (flags & NDR_OUT) {
17092                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17093         }
17094         return NDR_ERR_SUCCESS;
17095 }
17096
17097 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
17098 {
17099         TALLOC_CTX *_mem_save_handle_0;
17100         if (flags & NDR_IN) {
17101                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17102                         NDR_PULL_ALLOC(ndr, r->in.handle);
17103                 }
17104                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17105                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17106                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17108         }
17109         if (flags & NDR_OUT) {
17110                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17111         }
17112         return NDR_ERR_SUCCESS;
17113 }
17114
17115 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
17116 {
17117         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
17118         ndr->depth++;
17119         if (flags & NDR_SET_VALUES) {
17120                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17121         }
17122         if (flags & NDR_IN) {
17123                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
17124                 ndr->depth++;
17125                 ndr_print_ptr(ndr, "handle", r->in.handle);
17126                 ndr->depth++;
17127                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17128                 ndr->depth--;
17129                 ndr->depth--;
17130         }
17131         if (flags & NDR_OUT) {
17132                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
17133                 ndr->depth++;
17134                 ndr_print_WERROR(ndr, "result", r->out.result);
17135                 ndr->depth--;
17136         }
17137         ndr->depth--;
17138 }
17139
17140 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
17141 {
17142         if (flags & NDR_IN) {
17143                 if (r->in.handle == NULL) {
17144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17145                 }
17146                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17147                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
17149         }
17150         if (flags & NDR_OUT) {
17151                 if (r->out.num_written == NULL) {
17152                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17153                 }
17154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
17155                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17156         }
17157         return NDR_ERR_SUCCESS;
17158 }
17159
17160 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
17161 {
17162         TALLOC_CTX *_mem_save_handle_0;
17163         TALLOC_CTX *_mem_save_num_written_0;
17164         if (flags & NDR_IN) {
17165                 ZERO_STRUCT(r->out);
17166
17167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17168                         NDR_PULL_ALLOC(ndr, r->in.handle);
17169                 }
17170                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17171                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17172                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17174                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
17175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
17176                 NDR_PULL_ALLOC(ndr, r->out.num_written);
17177                 ZERO_STRUCTP(r->out.num_written);
17178         }
17179         if (flags & NDR_OUT) {
17180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17181                         NDR_PULL_ALLOC(ndr, r->out.num_written);
17182                 }
17183                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
17184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
17185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
17186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
17187                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17188         }
17189         return NDR_ERR_SUCCESS;
17190 }
17191
17192 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
17193 {
17194         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
17195         ndr->depth++;
17196         if (flags & NDR_SET_VALUES) {
17197                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17198         }
17199         if (flags & NDR_IN) {
17200                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
17201                 ndr->depth++;
17202                 ndr_print_ptr(ndr, "handle", r->in.handle);
17203                 ndr->depth++;
17204                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17205                 ndr->depth--;
17206                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
17207                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
17208                 ndr->depth--;
17209         }
17210         if (flags & NDR_OUT) {
17211                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
17212                 ndr->depth++;
17213                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
17214                 ndr->depth++;
17215                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
17216                 ndr->depth--;
17217                 ndr_print_WERROR(ndr, "result", r->out.result);
17218                 ndr->depth--;
17219         }
17220         ndr->depth--;
17221 }
17222
17223 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
17224 {
17225         if (flags & NDR_IN) {
17226                 if (r->in.handle == NULL) {
17227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17228                 }
17229                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17230         }
17231         if (flags & NDR_OUT) {
17232                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17233         }
17234         return NDR_ERR_SUCCESS;
17235 }
17236
17237 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
17238 {
17239         TALLOC_CTX *_mem_save_handle_0;
17240         if (flags & NDR_IN) {
17241                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17242                         NDR_PULL_ALLOC(ndr, r->in.handle);
17243                 }
17244                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17245                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17246                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17247                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17248         }
17249         if (flags & NDR_OUT) {
17250                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17251         }
17252         return NDR_ERR_SUCCESS;
17253 }
17254
17255 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
17256 {
17257         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
17258         ndr->depth++;
17259         if (flags & NDR_SET_VALUES) {
17260                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17261         }
17262         if (flags & NDR_IN) {
17263                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
17264                 ndr->depth++;
17265                 ndr_print_ptr(ndr, "handle", r->in.handle);
17266                 ndr->depth++;
17267                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17268                 ndr->depth--;
17269                 ndr->depth--;
17270         }
17271         if (flags & NDR_OUT) {
17272                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
17273                 ndr->depth++;
17274                 ndr_print_WERROR(ndr, "result", r->out.result);
17275                 ndr->depth--;
17276         }
17277         ndr->depth--;
17278 }
17279
17280 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
17281 {
17282         if (flags & NDR_IN) {
17283                 if (r->in.handle == NULL) {
17284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17285                 }
17286                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17287         }
17288         if (flags & NDR_OUT) {
17289                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17290         }
17291         return NDR_ERR_SUCCESS;
17292 }
17293
17294 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
17295 {
17296         TALLOC_CTX *_mem_save_handle_0;
17297         if (flags & NDR_IN) {
17298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17299                         NDR_PULL_ALLOC(ndr, r->in.handle);
17300                 }
17301                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17303                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17305         }
17306         if (flags & NDR_OUT) {
17307                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17308         }
17309         return NDR_ERR_SUCCESS;
17310 }
17311
17312 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
17313 {
17314         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
17315         ndr->depth++;
17316         if (flags & NDR_SET_VALUES) {
17317                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17318         }
17319         if (flags & NDR_IN) {
17320                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
17321                 ndr->depth++;
17322                 ndr_print_ptr(ndr, "handle", r->in.handle);
17323                 ndr->depth++;
17324                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17325                 ndr->depth--;
17326                 ndr->depth--;
17327         }
17328         if (flags & NDR_OUT) {
17329                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
17330                 ndr->depth++;
17331                 ndr_print_WERROR(ndr, "result", r->out.result);
17332                 ndr->depth--;
17333         }
17334         ndr->depth--;
17335 }
17336
17337 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
17338 {
17339         if (flags & NDR_IN) {
17340                 if (r->in.handle == NULL) {
17341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17342                 }
17343                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17345         }
17346         if (flags & NDR_OUT) {
17347                 if (r->out.data == NULL) {
17348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17349                 }
17350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17351                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
17352                 if (r->out._data_size == NULL) {
17353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17354                 }
17355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
17356                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17357         }
17358         return NDR_ERR_SUCCESS;
17359 }
17360
17361 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
17362 {
17363         TALLOC_CTX *_mem_save_handle_0;
17364         TALLOC_CTX *_mem_save__data_size_0;
17365         if (flags & NDR_IN) {
17366                 ZERO_STRUCT(r->out);
17367
17368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17369                         NDR_PULL_ALLOC(ndr, r->in.handle);
17370                 }
17371                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17372                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17373                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17374                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
17376                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
17377                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
17378                 NDR_PULL_ALLOC(ndr, r->out._data_size);
17379                 ZERO_STRUCTP(r->out._data_size);
17380         }
17381         if (flags & NDR_OUT) {
17382                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
17383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17384                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
17385                 }
17386                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
17387                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17388                         NDR_PULL_ALLOC(ndr, r->out._data_size);
17389                 }
17390                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
17391                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
17392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
17393                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
17394                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17395                 if (r->out.data) {
17396                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
17397                 }
17398         }
17399         return NDR_ERR_SUCCESS;
17400 }
17401
17402 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
17403 {
17404         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
17405         ndr->depth++;
17406         if (flags & NDR_SET_VALUES) {
17407                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17408         }
17409         if (flags & NDR_IN) {
17410                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
17411                 ndr->depth++;
17412                 ndr_print_ptr(ndr, "handle", r->in.handle);
17413                 ndr->depth++;
17414                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17415                 ndr->depth--;
17416                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
17417                 ndr->depth--;
17418         }
17419         if (flags & NDR_OUT) {
17420                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
17421                 ndr->depth++;
17422                 ndr_print_ptr(ndr, "data", r->out.data);
17423                 ndr->depth++;
17424                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
17425                 ndr->depth--;
17426                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
17427                 ndr->depth++;
17428                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
17429                 ndr->depth--;
17430                 ndr_print_WERROR(ndr, "result", r->out.result);
17431                 ndr->depth--;
17432         }
17433         ndr->depth--;
17434 }
17435
17436 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
17437 {
17438         if (flags & NDR_IN) {
17439                 if (r->in.handle == NULL) {
17440                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17441                 }
17442                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17443         }
17444         if (flags & NDR_OUT) {
17445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17446         }
17447         return NDR_ERR_SUCCESS;
17448 }
17449
17450 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
17451 {
17452         TALLOC_CTX *_mem_save_handle_0;
17453         if (flags & NDR_IN) {
17454                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17455                         NDR_PULL_ALLOC(ndr, r->in.handle);
17456                 }
17457                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17458                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17459                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17460                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17461         }
17462         if (flags & NDR_OUT) {
17463                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17464         }
17465         return NDR_ERR_SUCCESS;
17466 }
17467
17468 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
17469 {
17470         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
17471         ndr->depth++;
17472         if (flags & NDR_SET_VALUES) {
17473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17474         }
17475         if (flags & NDR_IN) {
17476                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
17477                 ndr->depth++;
17478                 ndr_print_ptr(ndr, "handle", r->in.handle);
17479                 ndr->depth++;
17480                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17481                 ndr->depth--;
17482                 ndr->depth--;
17483         }
17484         if (flags & NDR_OUT) {
17485                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
17486                 ndr->depth++;
17487                 ndr_print_WERROR(ndr, "result", r->out.result);
17488                 ndr->depth--;
17489         }
17490         ndr->depth--;
17491 }
17492
17493 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
17494 {
17495         if (flags & NDR_IN) {
17496                 if (r->in.handle == NULL) {
17497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17498                 }
17499                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17501                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17502                 if (r->in.buffer) {
17503                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17504                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
17505                 }
17506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17507         }
17508         if (flags & NDR_OUT) {
17509                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
17510                 if (r->out.buffer) {
17511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17512                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
17513                 }
17514                 if (r->out.needed == NULL) {
17515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17516                 }
17517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17519         }
17520         return NDR_ERR_SUCCESS;
17521 }
17522
17523 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
17524 {
17525         uint32_t _ptr_buffer;
17526         TALLOC_CTX *_mem_save_handle_0;
17527         TALLOC_CTX *_mem_save_buffer_0;
17528         TALLOC_CTX *_mem_save_needed_0;
17529         if (flags & NDR_IN) {
17530                 ZERO_STRUCT(r->out);
17531
17532                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17533                         NDR_PULL_ALLOC(ndr, r->in.handle);
17534                 }
17535                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17536                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17537                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17538                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17541                 if (_ptr_buffer) {
17542                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17543                 } else {
17544                         r->in.buffer = NULL;
17545                 }
17546                 if (r->in.buffer) {
17547                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17548                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
17550                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
17551                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
17552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17553                 }
17554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17555                 NDR_PULL_ALLOC(ndr, r->out.needed);
17556                 ZERO_STRUCTP(r->out.needed);
17557                 if (r->in.buffer) {
17558                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
17559                 }
17560         }
17561         if (flags & NDR_OUT) {
17562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17563                 if (_ptr_buffer) {
17564                         NDR_PULL_ALLOC(ndr, r->out.buffer);
17565                 } else {
17566                         r->out.buffer = NULL;
17567                 }
17568                 if (r->out.buffer) {
17569                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17570                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
17571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
17572                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
17573                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
17574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17575                 }
17576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17577                         NDR_PULL_ALLOC(ndr, r->out.needed);
17578                 }
17579                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17580                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17584                 if (r->out.buffer) {
17585                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
17586                 }
17587         }
17588         return NDR_ERR_SUCCESS;
17589 }
17590
17591 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
17592 {
17593         ndr_print_struct(ndr, name, "spoolss_AddJob");
17594         ndr->depth++;
17595         if (flags & NDR_SET_VALUES) {
17596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17597         }
17598         if (flags & NDR_IN) {
17599                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
17600                 ndr->depth++;
17601                 ndr_print_ptr(ndr, "handle", r->in.handle);
17602                 ndr->depth++;
17603                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17604                 ndr->depth--;
17605                 ndr_print_uint32(ndr, "level", r->in.level);
17606                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17607                 ndr->depth++;
17608                 if (r->in.buffer) {
17609                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
17610                 }
17611                 ndr->depth--;
17612                 ndr_print_uint32(ndr, "offered", r->in.offered);
17613                 ndr->depth--;
17614         }
17615         if (flags & NDR_OUT) {
17616                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
17617                 ndr->depth++;
17618                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
17619                 ndr->depth++;
17620                 if (r->out.buffer) {
17621                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
17622                 }
17623                 ndr->depth--;
17624                 ndr_print_ptr(ndr, "needed", r->out.needed);
17625                 ndr->depth++;
17626                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17627                 ndr->depth--;
17628                 ndr_print_WERROR(ndr, "result", r->out.result);
17629                 ndr->depth--;
17630         }
17631         ndr->depth--;
17632 }
17633
17634 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
17635 {
17636         if (flags & NDR_IN) {
17637                 if (r->in.handle == NULL) {
17638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17639                 }
17640                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
17642         }
17643         if (flags & NDR_OUT) {
17644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17645         }
17646         return NDR_ERR_SUCCESS;
17647 }
17648
17649 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
17650 {
17651         TALLOC_CTX *_mem_save_handle_0;
17652         if (flags & NDR_IN) {
17653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17654                         NDR_PULL_ALLOC(ndr, r->in.handle);
17655                 }
17656                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17657                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17658                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17659                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
17661         }
17662         if (flags & NDR_OUT) {
17663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17664         }
17665         return NDR_ERR_SUCCESS;
17666 }
17667
17668 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
17669 {
17670         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
17671         ndr->depth++;
17672         if (flags & NDR_SET_VALUES) {
17673                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17674         }
17675         if (flags & NDR_IN) {
17676                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
17677                 ndr->depth++;
17678                 ndr_print_ptr(ndr, "handle", r->in.handle);
17679                 ndr->depth++;
17680                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17681                 ndr->depth--;
17682                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
17683                 ndr->depth--;
17684         }
17685         if (flags & NDR_OUT) {
17686                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
17687                 ndr->depth++;
17688                 ndr_print_WERROR(ndr, "result", r->out.result);
17689                 ndr->depth--;
17690         }
17691         ndr->depth--;
17692 }
17693
17694 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
17695 {
17696         if (flags & NDR_IN) {
17697                 if (r->in.handle == NULL) {
17698                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17699                 }
17700                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17704                 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));
17705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17706         }
17707         if (flags & NDR_OUT) {
17708                 if (r->out.type == NULL) {
17709                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17710                 }
17711                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
17712                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
17713                 if (r->out.needed == NULL) {
17714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17715                 }
17716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17718         }
17719         return NDR_ERR_SUCCESS;
17720 }
17721
17722 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
17723 {
17724         TALLOC_CTX *_mem_save_handle_0;
17725         TALLOC_CTX *_mem_save_type_0;
17726         TALLOC_CTX *_mem_save_needed_0;
17727         if (flags & NDR_IN) {
17728                 ZERO_STRUCT(r->out);
17729
17730                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17731                         NDR_PULL_ALLOC(ndr, r->in.handle);
17732                 }
17733                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17734                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17735                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17737                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17738                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17739                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17740                         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));
17741                 }
17742                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17743                 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));
17744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17745                 NDR_PULL_ALLOC(ndr, r->out.type);
17746                 ZERO_STRUCTP(r->out.type);
17747                 NDR_PULL_ALLOC(ndr, r->out.needed);
17748                 ZERO_STRUCTP(r->out.needed);
17749         }
17750         if (flags & NDR_OUT) {
17751                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17752                         NDR_PULL_ALLOC(ndr, r->out.type);
17753                 }
17754                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
17755                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
17756                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
17757                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
17758                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
17759                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17760                         NDR_PULL_ALLOC(ndr, r->out.needed);
17761                 }
17762                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17763                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17765                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17766                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17767         }
17768         return NDR_ERR_SUCCESS;
17769 }
17770
17771 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
17772 {
17773         if (flags & NDR_IN) {
17774                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17775         }
17776         if (flags & NDR_OUT) {
17777                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17778                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17779         }
17780         return NDR_ERR_SUCCESS;
17781 }
17782
17783 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
17784 {
17785         if (flags & NDR_IN) {
17786                 ZERO_STRUCT(r->out);
17787
17788                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17789         }
17790         if (flags & NDR_OUT) {
17791                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
17792                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17793         }
17794         return NDR_ERR_SUCCESS;
17795 }
17796
17797 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
17798 {
17799         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
17800         ndr->depth++;
17801         if (flags & NDR_SET_VALUES) {
17802                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17803         }
17804         if (flags & NDR_IN) {
17805                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
17806                 ndr->depth++;
17807                 ndr_print_ptr(ndr, "handle", r->in.handle);
17808                 ndr->depth++;
17809                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17810                 ndr->depth--;
17811                 ndr_print_string(ndr, "value_name", r->in.value_name);
17812                 ndr_print_uint32(ndr, "offered", r->in.offered);
17813                 ndr->depth--;
17814         }
17815         if (flags & NDR_OUT) {
17816                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
17817                 ndr->depth++;
17818                 ndr_print_ptr(ndr, "type", r->out.type);
17819                 ndr->depth++;
17820                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
17821                 ndr->depth--;
17822                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
17823                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
17824                 ndr_print_ptr(ndr, "needed", r->out.needed);
17825                 ndr->depth++;
17826                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17827                 ndr->depth--;
17828                 ndr_print_WERROR(ndr, "result", r->out.result);
17829                 ndr->depth--;
17830         }
17831         ndr->depth--;
17832 }
17833
17834 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
17835 {
17836         if (flags & NDR_IN) {
17837                 if (r->in.handle == NULL) {
17838                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17839                 }
17840                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17844                 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));
17845                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17846                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
17848         }
17849         if (flags & NDR_OUT) {
17850                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17851         }
17852         return NDR_ERR_SUCCESS;
17853 }
17854
17855 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
17856 {
17857         if (flags & NDR_IN) {
17858                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17859         }
17860         if (flags & NDR_OUT) {
17861                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17862                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17863         }
17864         return NDR_ERR_SUCCESS;
17865 }
17866
17867 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
17868 {
17869         TALLOC_CTX *_mem_save_handle_0;
17870         if (flags & NDR_IN) {
17871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17872                         NDR_PULL_ALLOC(ndr, r->in.handle);
17873                 }
17874                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17878                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17879                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17880                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17881                         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));
17882                 }
17883                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17884                 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));
17885                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17886                 {
17887                         struct ndr_pull *_ndr_data;
17888                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
17889                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
17890                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
17891                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
17892                 }
17893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
17894         }
17895         if (flags & NDR_OUT) {
17896                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17897         }
17898         return NDR_ERR_SUCCESS;
17899 }
17900
17901 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
17902 {
17903         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
17904         ndr->depth++;
17905         if (flags & NDR_SET_VALUES) {
17906                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17907         }
17908         if (flags & NDR_IN) {
17909                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
17910                 ndr->depth++;
17911                 ndr_print_ptr(ndr, "handle", r->in.handle);
17912                 ndr->depth++;
17913                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17914                 ndr->depth--;
17915                 ndr_print_string(ndr, "value_name", r->in.value_name);
17916                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
17917                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
17918                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
17919                 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);
17920                 ndr->depth--;
17921         }
17922         if (flags & NDR_OUT) {
17923                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
17924                 ndr->depth++;
17925                 ndr_print_WERROR(ndr, "result", r->out.result);
17926                 ndr->depth--;
17927         }
17928         ndr->depth--;
17929 }
17930
17931 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
17932 {
17933         if (flags & NDR_IN) {
17934         }
17935         if (flags & NDR_OUT) {
17936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17937         }
17938         return NDR_ERR_SUCCESS;
17939 }
17940
17941 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
17942 {
17943         if (flags & NDR_IN) {
17944         }
17945         if (flags & NDR_OUT) {
17946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17947         }
17948         return NDR_ERR_SUCCESS;
17949 }
17950
17951 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
17952 {
17953         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
17954         ndr->depth++;
17955         if (flags & NDR_SET_VALUES) {
17956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17957         }
17958         if (flags & NDR_IN) {
17959                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
17960                 ndr->depth++;
17961                 ndr->depth--;
17962         }
17963         if (flags & NDR_OUT) {
17964                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
17965                 ndr->depth++;
17966                 ndr_print_WERROR(ndr, "result", r->out.result);
17967                 ndr->depth--;
17968         }
17969         ndr->depth--;
17970 }
17971
17972 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
17973 {
17974         if (flags & NDR_IN) {
17975                 if (r->in.handle == NULL) {
17976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17977                 }
17978                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17979         }
17980         if (flags & NDR_OUT) {
17981                 if (r->out.handle == NULL) {
17982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17983                 }
17984                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17985                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17986         }
17987         return NDR_ERR_SUCCESS;
17988 }
17989
17990 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
17991 {
17992         TALLOC_CTX *_mem_save_handle_0;
17993         if (flags & NDR_IN) {
17994                 ZERO_STRUCT(r->out);
17995
17996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17997                         NDR_PULL_ALLOC(ndr, r->in.handle);
17998                 }
17999                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18000                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18001                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18003                 NDR_PULL_ALLOC(ndr, r->out.handle);
18004                 *r->out.handle = *r->in.handle;
18005         }
18006         if (flags & NDR_OUT) {
18007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18008                         NDR_PULL_ALLOC(ndr, r->out.handle);
18009                 }
18010                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18011                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18012                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18015         }
18016         return NDR_ERR_SUCCESS;
18017 }
18018
18019 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
18020 {
18021         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
18022         ndr->depth++;
18023         if (flags & NDR_SET_VALUES) {
18024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18025         }
18026         if (flags & NDR_IN) {
18027                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
18028                 ndr->depth++;
18029                 ndr_print_ptr(ndr, "handle", r->in.handle);
18030                 ndr->depth++;
18031                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18032                 ndr->depth--;
18033                 ndr->depth--;
18034         }
18035         if (flags & NDR_OUT) {
18036                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
18037                 ndr->depth++;
18038                 ndr_print_ptr(ndr, "handle", r->out.handle);
18039                 ndr->depth++;
18040                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18041                 ndr->depth--;
18042                 ndr_print_WERROR(ndr, "result", r->out.result);
18043                 ndr->depth--;
18044         }
18045         ndr->depth--;
18046 }
18047
18048 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
18049 {
18050         if (flags & NDR_IN) {
18051                 if (r->in.handle == NULL) {
18052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18053                 }
18054                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18056                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18057                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18058         }
18059         if (flags & NDR_OUT) {
18060                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18061         }
18062         return NDR_ERR_SUCCESS;
18063 }
18064
18065 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
18066 {
18067         TALLOC_CTX *_mem_save_handle_0;
18068         if (flags & NDR_IN) {
18069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18070                         NDR_PULL_ALLOC(ndr, r->in.handle);
18071                 }
18072                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18073                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18074                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18077                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18078                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18079         }
18080         if (flags & NDR_OUT) {
18081                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18082         }
18083         return NDR_ERR_SUCCESS;
18084 }
18085
18086 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
18087 {
18088         ndr_print_struct(ndr, name, "spoolss_AddForm");
18089         ndr->depth++;
18090         if (flags & NDR_SET_VALUES) {
18091                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18092         }
18093         if (flags & NDR_IN) {
18094                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
18095                 ndr->depth++;
18096                 ndr_print_ptr(ndr, "handle", r->in.handle);
18097                 ndr->depth++;
18098                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18099                 ndr->depth--;
18100                 ndr_print_uint32(ndr, "level", r->in.level);
18101                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18102                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18103                 ndr->depth--;
18104         }
18105         if (flags & NDR_OUT) {
18106                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
18107                 ndr->depth++;
18108                 ndr_print_WERROR(ndr, "result", r->out.result);
18109                 ndr->depth--;
18110         }
18111         ndr->depth--;
18112 }
18113
18114 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
18115 {
18116         if (flags & NDR_IN) {
18117                 if (r->in.handle == NULL) {
18118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18119                 }
18120                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18124                 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));
18125         }
18126         if (flags & NDR_OUT) {
18127                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18128         }
18129         return NDR_ERR_SUCCESS;
18130 }
18131
18132 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
18133 {
18134         TALLOC_CTX *_mem_save_handle_0;
18135         if (flags & NDR_IN) {
18136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18137                         NDR_PULL_ALLOC(ndr, r->in.handle);
18138                 }
18139                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18140                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18141                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18143                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18144                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18145                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18146                         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));
18147                 }
18148                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18149                 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));
18150         }
18151         if (flags & NDR_OUT) {
18152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18153         }
18154         return NDR_ERR_SUCCESS;
18155 }
18156
18157 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
18158 {
18159         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
18160         ndr->depth++;
18161         if (flags & NDR_SET_VALUES) {
18162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18163         }
18164         if (flags & NDR_IN) {
18165                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
18166                 ndr->depth++;
18167                 ndr_print_ptr(ndr, "handle", r->in.handle);
18168                 ndr->depth++;
18169                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18170                 ndr->depth--;
18171                 ndr_print_string(ndr, "form_name", r->in.form_name);
18172                 ndr->depth--;
18173         }
18174         if (flags & NDR_OUT) {
18175                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
18176                 ndr->depth++;
18177                 ndr_print_WERROR(ndr, "result", r->out.result);
18178                 ndr->depth--;
18179         }
18180         ndr->depth--;
18181 }
18182
18183 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
18184 {
18185         if (flags & NDR_IN) {
18186                 if (r->in.handle == NULL) {
18187                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18188                 }
18189                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18193                 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));
18194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18196                 if (r->in.buffer) {
18197                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18198                 }
18199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18200         }
18201         if (flags & NDR_OUT) {
18202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18203                 if (r->out.info) {
18204                         {
18205                                 struct ndr_push *_ndr_info;
18206                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18207                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18208                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18209                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18210                         }
18211                 }
18212                 if (r->out.needed == NULL) {
18213                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18214                 }
18215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18216                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18217         }
18218         return NDR_ERR_SUCCESS;
18219 }
18220
18221 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
18222 {
18223         uint32_t _ptr_buffer;
18224         uint32_t _ptr_info;
18225         TALLOC_CTX *_mem_save_handle_0;
18226         TALLOC_CTX *_mem_save_buffer_0;
18227         TALLOC_CTX *_mem_save_info_0;
18228         TALLOC_CTX *_mem_save_needed_0;
18229         if (flags & NDR_IN) {
18230                 ZERO_STRUCT(r->out);
18231
18232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18233                         NDR_PULL_ALLOC(ndr, r->in.handle);
18234                 }
18235                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18236                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18237                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18239                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18240                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18241                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18242                         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));
18243                 }
18244                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18245                 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));
18246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18247                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18248                 if (_ptr_buffer) {
18249                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18250                 } else {
18251                         r->in.buffer = NULL;
18252                 }
18253                 if (r->in.buffer) {
18254                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18255                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18256                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18258                 }
18259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18260                 NDR_PULL_ALLOC(ndr, r->out.needed);
18261                 ZERO_STRUCTP(r->out.needed);
18262         }
18263         if (flags & NDR_OUT) {
18264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18265                 if (_ptr_info) {
18266                         NDR_PULL_ALLOC(ndr, r->out.info);
18267                 } else {
18268                         r->out.info = NULL;
18269                 }
18270                 if (r->out.info) {
18271                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18272                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18273                         {
18274                                 struct ndr_pull *_ndr_info;
18275                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18276                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18277                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18278                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18279                         }
18280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18281                 }
18282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18283                         NDR_PULL_ALLOC(ndr, r->out.needed);
18284                 }
18285                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18286                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18289                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18290         }
18291         return NDR_ERR_SUCCESS;
18292 }
18293
18294 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
18295 {
18296         ndr_print_struct(ndr, name, "spoolss_GetForm");
18297         ndr->depth++;
18298         if (flags & NDR_SET_VALUES) {
18299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18300         }
18301         if (flags & NDR_IN) {
18302                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
18303                 ndr->depth++;
18304                 ndr_print_ptr(ndr, "handle", r->in.handle);
18305                 ndr->depth++;
18306                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18307                 ndr->depth--;
18308                 ndr_print_string(ndr, "form_name", r->in.form_name);
18309                 ndr_print_uint32(ndr, "level", r->in.level);
18310                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18311                 ndr->depth++;
18312                 if (r->in.buffer) {
18313                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18314                 }
18315                 ndr->depth--;
18316                 ndr_print_uint32(ndr, "offered", r->in.offered);
18317                 ndr->depth--;
18318         }
18319         if (flags & NDR_OUT) {
18320                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
18321                 ndr->depth++;
18322                 ndr_print_ptr(ndr, "info", r->out.info);
18323                 ndr->depth++;
18324                 if (r->out.info) {
18325                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18326                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
18327                 }
18328                 ndr->depth--;
18329                 ndr_print_ptr(ndr, "needed", r->out.needed);
18330                 ndr->depth++;
18331                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18332                 ndr->depth--;
18333                 ndr_print_WERROR(ndr, "result", r->out.result);
18334                 ndr->depth--;
18335         }
18336         ndr->depth--;
18337 }
18338
18339 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
18340 {
18341         if (flags & NDR_IN) {
18342                 if (r->in.handle == NULL) {
18343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18344                 }
18345                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18349                 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));
18350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18351                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18352                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18353         }
18354         if (flags & NDR_OUT) {
18355                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18356         }
18357         return NDR_ERR_SUCCESS;
18358 }
18359
18360 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
18361 {
18362         TALLOC_CTX *_mem_save_handle_0;
18363         if (flags & NDR_IN) {
18364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18365                         NDR_PULL_ALLOC(ndr, r->in.handle);
18366                 }
18367                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18368                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18369                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18371                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18372                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18373                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18374                         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));
18375                 }
18376                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18377                 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));
18378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18379                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18380                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18381         }
18382         if (flags & NDR_OUT) {
18383                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18384         }
18385         return NDR_ERR_SUCCESS;
18386 }
18387
18388 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
18389 {
18390         ndr_print_struct(ndr, name, "spoolss_SetForm");
18391         ndr->depth++;
18392         if (flags & NDR_SET_VALUES) {
18393                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18394         }
18395         if (flags & NDR_IN) {
18396                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
18397                 ndr->depth++;
18398                 ndr_print_ptr(ndr, "handle", r->in.handle);
18399                 ndr->depth++;
18400                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18401                 ndr->depth--;
18402                 ndr_print_string(ndr, "form_name", r->in.form_name);
18403                 ndr_print_uint32(ndr, "level", r->in.level);
18404                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18405                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18406                 ndr->depth--;
18407         }
18408         if (flags & NDR_OUT) {
18409                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
18410                 ndr->depth++;
18411                 ndr_print_WERROR(ndr, "result", r->out.result);
18412                 ndr->depth--;
18413         }
18414         ndr->depth--;
18415 }
18416
18417 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
18418 {
18419         if (flags & NDR_IN) {
18420                 if (r->in.handle == NULL) {
18421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18422                 }
18423                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18426                 if (r->in.buffer) {
18427                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18428                 }
18429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18430         }
18431         if (flags & NDR_OUT) {
18432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18433                 if (r->out.info) {
18434                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18435                 }
18436                 if (r->out.needed == NULL) {
18437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18438                 }
18439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18440                 if (r->out.count == NULL) {
18441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18442                 }
18443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18445         }
18446         return NDR_ERR_SUCCESS;
18447 }
18448
18449 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
18450 {
18451         uint32_t _ptr_buffer;
18452         uint32_t _ptr_info;
18453         TALLOC_CTX *_mem_save_handle_0;
18454         TALLOC_CTX *_mem_save_buffer_0;
18455         TALLOC_CTX *_mem_save_info_0;
18456         TALLOC_CTX *_mem_save_needed_0;
18457         TALLOC_CTX *_mem_save_count_0;
18458         if (flags & NDR_IN) {
18459                 ZERO_STRUCT(r->out);
18460
18461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18462                         NDR_PULL_ALLOC(ndr, r->in.handle);
18463                 }
18464                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18465                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18466                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18470                 if (_ptr_buffer) {
18471                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18472                 } else {
18473                         r->in.buffer = NULL;
18474                 }
18475                 if (r->in.buffer) {
18476                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18477                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18478                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18480                 }
18481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18482                 NDR_PULL_ALLOC(ndr, r->out.needed);
18483                 ZERO_STRUCTP(r->out.needed);
18484                 NDR_PULL_ALLOC(ndr, r->out.count);
18485                 ZERO_STRUCTP(r->out.count);
18486         }
18487         if (flags & NDR_OUT) {
18488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18489                 if (_ptr_info) {
18490                         NDR_PULL_ALLOC(ndr, r->out.info);
18491                 } else {
18492                         r->out.info = NULL;
18493                 }
18494                 if (r->out.info) {
18495                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18496                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18497                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18499                 }
18500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18501                         NDR_PULL_ALLOC(ndr, r->out.needed);
18502                 }
18503                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18504                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18508                         NDR_PULL_ALLOC(ndr, r->out.count);
18509                 }
18510                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18511                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18514                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18515         }
18516         return NDR_ERR_SUCCESS;
18517 }
18518
18519 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
18520 {
18521         uint32_t cntr_info_0;
18522         if (flags & NDR_IN) {
18523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18525         }
18526         if (flags & NDR_OUT) {
18527                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18528                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18529                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18530                 }
18531                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18532                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18533                 }
18534         }
18535         return NDR_ERR_SUCCESS;
18536 }
18537
18538 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
18539 {
18540         uint32_t cntr_info_0;
18541         TALLOC_CTX *_mem_save_info_0;
18542         if (flags & NDR_IN) {
18543                 ZERO_STRUCT(r->out);
18544
18545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18547         }
18548         if (flags & NDR_OUT) {
18549                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18550                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18552                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18553                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18554                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18555                 }
18556                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18557                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18558                 }
18559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18560         }
18561         return NDR_ERR_SUCCESS;
18562 }
18563
18564 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
18565 {
18566         uint32_t cntr_info_1;
18567         ndr_print_struct(ndr, name, "spoolss_EnumForms");
18568         ndr->depth++;
18569         if (flags & NDR_SET_VALUES) {
18570                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18571         }
18572         if (flags & NDR_IN) {
18573                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
18574                 ndr->depth++;
18575                 ndr_print_ptr(ndr, "handle", r->in.handle);
18576                 ndr->depth++;
18577                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18578                 ndr->depth--;
18579                 ndr_print_uint32(ndr, "level", r->in.level);
18580                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18581                 ndr->depth++;
18582                 if (r->in.buffer) {
18583                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18584                 }
18585                 ndr->depth--;
18586                 ndr_print_uint32(ndr, "offered", r->in.offered);
18587                 ndr->depth--;
18588         }
18589         if (flags & NDR_OUT) {
18590                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
18591                 ndr->depth++;
18592                 ndr_print_ptr(ndr, "count", r->out.count);
18593                 ndr->depth++;
18594                 ndr_print_uint32(ndr, "count", *r->out.count);
18595                 ndr->depth--;
18596                 ndr_print_ptr(ndr, "info", r->out.info);
18597                 ndr->depth++;
18598                 if (r->out.info) {
18599                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18600                         ndr->depth++;
18601                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18602                                 char *idx_1=NULL;
18603                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18604                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18605                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
18606                                         free(idx_1);
18607                                 }
18608                         }
18609                         ndr->depth--;
18610                 }
18611                 ndr->depth--;
18612                 ndr_print_ptr(ndr, "needed", r->out.needed);
18613                 ndr->depth++;
18614                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18615                 ndr->depth--;
18616                 ndr_print_WERROR(ndr, "result", r->out.result);
18617                 ndr->depth--;
18618         }
18619         ndr->depth--;
18620 }
18621
18622 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
18623 {
18624         if (flags & NDR_IN) {
18625                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18626                 if (r->in.servername) {
18627                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18630                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18631                 }
18632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18634                 if (r->in.buffer) {
18635                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18636                 }
18637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18638         }
18639         if (flags & NDR_OUT) {
18640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18641                 if (r->out.info) {
18642                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18643                 }
18644                 if (r->out.needed == NULL) {
18645                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18646                 }
18647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18648                 if (r->out.count == NULL) {
18649                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18650                 }
18651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18653         }
18654         return NDR_ERR_SUCCESS;
18655 }
18656
18657 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
18658 {
18659         uint32_t _ptr_servername;
18660         uint32_t _ptr_buffer;
18661         uint32_t _ptr_info;
18662         TALLOC_CTX *_mem_save_servername_0;
18663         TALLOC_CTX *_mem_save_buffer_0;
18664         TALLOC_CTX *_mem_save_info_0;
18665         TALLOC_CTX *_mem_save_needed_0;
18666         TALLOC_CTX *_mem_save_count_0;
18667         if (flags & NDR_IN) {
18668                 ZERO_STRUCT(r->out);
18669
18670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18671                 if (_ptr_servername) {
18672                         NDR_PULL_ALLOC(ndr, r->in.servername);
18673                 } else {
18674                         r->in.servername = NULL;
18675                 }
18676                 if (r->in.servername) {
18677                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18678                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18679                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18680                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18681                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18682                                 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));
18683                         }
18684                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18685                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18687                 }
18688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18689                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18690                 if (_ptr_buffer) {
18691                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18692                 } else {
18693                         r->in.buffer = NULL;
18694                 }
18695                 if (r->in.buffer) {
18696                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18697                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18698                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18700                 }
18701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18702                 NDR_PULL_ALLOC(ndr, r->out.needed);
18703                 ZERO_STRUCTP(r->out.needed);
18704                 NDR_PULL_ALLOC(ndr, r->out.count);
18705                 ZERO_STRUCTP(r->out.count);
18706         }
18707         if (flags & NDR_OUT) {
18708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18709                 if (_ptr_info) {
18710                         NDR_PULL_ALLOC(ndr, r->out.info);
18711                 } else {
18712                         r->out.info = NULL;
18713                 }
18714                 if (r->out.info) {
18715                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18716                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18717                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18719                 }
18720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18721                         NDR_PULL_ALLOC(ndr, r->out.needed);
18722                 }
18723                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18724                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18728                         NDR_PULL_ALLOC(ndr, r->out.count);
18729                 }
18730                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18731                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18734                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18735         }
18736         return NDR_ERR_SUCCESS;
18737 }
18738
18739 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
18740 {
18741         uint32_t cntr_info_0;
18742         if (flags & NDR_IN) {
18743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18745         }
18746         if (flags & NDR_OUT) {
18747                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18748                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18749                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18750                 }
18751                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18752                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18753                 }
18754         }
18755         return NDR_ERR_SUCCESS;
18756 }
18757
18758 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
18759 {
18760         uint32_t cntr_info_0;
18761         TALLOC_CTX *_mem_save_info_0;
18762         if (flags & NDR_IN) {
18763                 ZERO_STRUCT(r->out);
18764
18765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18767         }
18768         if (flags & NDR_OUT) {
18769                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18770                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18771                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18772                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18773                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18774                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18775                 }
18776                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18777                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18778                 }
18779                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18780         }
18781         return NDR_ERR_SUCCESS;
18782 }
18783
18784 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
18785 {
18786         uint32_t cntr_info_1;
18787         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
18788         ndr->depth++;
18789         if (flags & NDR_SET_VALUES) {
18790                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18791         }
18792         if (flags & NDR_IN) {
18793                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
18794                 ndr->depth++;
18795                 ndr_print_ptr(ndr, "servername", r->in.servername);
18796                 ndr->depth++;
18797                 if (r->in.servername) {
18798                         ndr_print_string(ndr, "servername", r->in.servername);
18799                 }
18800                 ndr->depth--;
18801                 ndr_print_uint32(ndr, "level", r->in.level);
18802                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18803                 ndr->depth++;
18804                 if (r->in.buffer) {
18805                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18806                 }
18807                 ndr->depth--;
18808                 ndr_print_uint32(ndr, "offered", r->in.offered);
18809                 ndr->depth--;
18810         }
18811         if (flags & NDR_OUT) {
18812                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
18813                 ndr->depth++;
18814                 ndr_print_ptr(ndr, "count", r->out.count);
18815                 ndr->depth++;
18816                 ndr_print_uint32(ndr, "count", *r->out.count);
18817                 ndr->depth--;
18818                 ndr_print_ptr(ndr, "info", r->out.info);
18819                 ndr->depth++;
18820                 if (r->out.info) {
18821                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18822                         ndr->depth++;
18823                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18824                                 char *idx_1=NULL;
18825                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18826                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18827                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
18828                                         free(idx_1);
18829                                 }
18830                         }
18831                         ndr->depth--;
18832                 }
18833                 ndr->depth--;
18834                 ndr_print_ptr(ndr, "needed", r->out.needed);
18835                 ndr->depth++;
18836                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18837                 ndr->depth--;
18838                 ndr_print_WERROR(ndr, "result", r->out.result);
18839                 ndr->depth--;
18840         }
18841         ndr->depth--;
18842 }
18843
18844 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
18845 {
18846         if (flags & NDR_IN) {
18847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18848                 if (r->in.servername) {
18849                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18852                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18853                 }
18854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18855                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18856                 if (r->in.buffer) {
18857                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18858                 }
18859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18860         }
18861         if (flags & NDR_OUT) {
18862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18863                 if (r->out.info) {
18864                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18865                 }
18866                 if (r->out.needed == NULL) {
18867                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18868                 }
18869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18870                 if (r->out.count == NULL) {
18871                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18872                 }
18873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18874                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18875         }
18876         return NDR_ERR_SUCCESS;
18877 }
18878
18879 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
18880 {
18881         uint32_t _ptr_servername;
18882         uint32_t _ptr_buffer;
18883         uint32_t _ptr_info;
18884         TALLOC_CTX *_mem_save_servername_0;
18885         TALLOC_CTX *_mem_save_buffer_0;
18886         TALLOC_CTX *_mem_save_info_0;
18887         TALLOC_CTX *_mem_save_needed_0;
18888         TALLOC_CTX *_mem_save_count_0;
18889         if (flags & NDR_IN) {
18890                 ZERO_STRUCT(r->out);
18891
18892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18893                 if (_ptr_servername) {
18894                         NDR_PULL_ALLOC(ndr, r->in.servername);
18895                 } else {
18896                         r->in.servername = NULL;
18897                 }
18898                 if (r->in.servername) {
18899                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18900                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18901                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18902                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18903                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18904                                 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));
18905                         }
18906                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18907                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18909                 }
18910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18912                 if (_ptr_buffer) {
18913                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18914                 } else {
18915                         r->in.buffer = NULL;
18916                 }
18917                 if (r->in.buffer) {
18918                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18919                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18920                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18922                 }
18923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18924                 NDR_PULL_ALLOC(ndr, r->out.needed);
18925                 ZERO_STRUCTP(r->out.needed);
18926                 NDR_PULL_ALLOC(ndr, r->out.count);
18927                 ZERO_STRUCTP(r->out.count);
18928         }
18929         if (flags & NDR_OUT) {
18930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18931                 if (_ptr_info) {
18932                         NDR_PULL_ALLOC(ndr, r->out.info);
18933                 } else {
18934                         r->out.info = NULL;
18935                 }
18936                 if (r->out.info) {
18937                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18938                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18939                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18941                 }
18942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18943                         NDR_PULL_ALLOC(ndr, r->out.needed);
18944                 }
18945                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18946                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18950                         NDR_PULL_ALLOC(ndr, r->out.count);
18951                 }
18952                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18953                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18956                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18957         }
18958         return NDR_ERR_SUCCESS;
18959 }
18960
18961 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
18962 {
18963         uint32_t cntr_info_0;
18964         if (flags & NDR_IN) {
18965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18967         }
18968         if (flags & NDR_OUT) {
18969                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18970                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18971                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18972                 }
18973                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18974                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18975                 }
18976         }
18977         return NDR_ERR_SUCCESS;
18978 }
18979
18980 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
18981 {
18982         uint32_t cntr_info_0;
18983         TALLOC_CTX *_mem_save_info_0;
18984         if (flags & NDR_IN) {
18985                 ZERO_STRUCT(r->out);
18986
18987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18989         }
18990         if (flags & NDR_OUT) {
18991                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18992                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18993                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18994                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18995                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18996                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18997                 }
18998                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18999                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19000                 }
19001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19002         }
19003         return NDR_ERR_SUCCESS;
19004 }
19005
19006 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
19007 {
19008         uint32_t cntr_info_1;
19009         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
19010         ndr->depth++;
19011         if (flags & NDR_SET_VALUES) {
19012                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19013         }
19014         if (flags & NDR_IN) {
19015                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
19016                 ndr->depth++;
19017                 ndr_print_ptr(ndr, "servername", r->in.servername);
19018                 ndr->depth++;
19019                 if (r->in.servername) {
19020                         ndr_print_string(ndr, "servername", r->in.servername);
19021                 }
19022                 ndr->depth--;
19023                 ndr_print_uint32(ndr, "level", r->in.level);
19024                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19025                 ndr->depth++;
19026                 if (r->in.buffer) {
19027                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19028                 }
19029                 ndr->depth--;
19030                 ndr_print_uint32(ndr, "offered", r->in.offered);
19031                 ndr->depth--;
19032         }
19033         if (flags & NDR_OUT) {
19034                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
19035                 ndr->depth++;
19036                 ndr_print_ptr(ndr, "count", r->out.count);
19037                 ndr->depth++;
19038                 ndr_print_uint32(ndr, "count", *r->out.count);
19039                 ndr->depth--;
19040                 ndr_print_ptr(ndr, "info", r->out.info);
19041                 ndr->depth++;
19042                 if (r->out.info) {
19043                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19044                         ndr->depth++;
19045                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19046                                 char *idx_1=NULL;
19047                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19048                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
19049                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
19050                                         free(idx_1);
19051                                 }
19052                         }
19053                         ndr->depth--;
19054                 }
19055                 ndr->depth--;
19056                 ndr_print_ptr(ndr, "needed", r->out.needed);
19057                 ndr->depth++;
19058                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19059                 ndr->depth--;
19060                 ndr_print_WERROR(ndr, "result", r->out.result);
19061                 ndr->depth--;
19062         }
19063         ndr->depth--;
19064 }
19065
19066 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
19067 {
19068         if (flags & NDR_IN) {
19069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
19070                 if (r->in.server_name) {
19071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19074                         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));
19075                 }
19076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
19077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19080                 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));
19081         }
19082         if (flags & NDR_OUT) {
19083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19084         }
19085         return NDR_ERR_SUCCESS;
19086 }
19087
19088 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
19089 {
19090         uint32_t _ptr_server_name;
19091         TALLOC_CTX *_mem_save_server_name_0;
19092         if (flags & NDR_IN) {
19093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
19094                 if (_ptr_server_name) {
19095                         NDR_PULL_ALLOC(ndr, r->in.server_name);
19096                 } else {
19097                         r->in.server_name = NULL;
19098                 }
19099                 if (r->in.server_name) {
19100                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19101                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
19102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
19103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
19104                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
19105                                 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));
19106                         }
19107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
19108                         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));
19109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
19110                 }
19111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
19112                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
19113                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
19114                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
19115                         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));
19116                 }
19117                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
19118                 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));
19119         }
19120         if (flags & NDR_OUT) {
19121                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19122         }
19123         return NDR_ERR_SUCCESS;
19124 }
19125
19126 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
19127 {
19128         ndr_print_struct(ndr, name, "spoolss_AddPort");
19129         ndr->depth++;
19130         if (flags & NDR_SET_VALUES) {
19131                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19132         }
19133         if (flags & NDR_IN) {
19134                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
19135                 ndr->depth++;
19136                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
19137                 ndr->depth++;
19138                 if (r->in.server_name) {
19139                         ndr_print_string(ndr, "server_name", r->in.server_name);
19140                 }
19141                 ndr->depth--;
19142                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
19143                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
19144                 ndr->depth--;
19145         }
19146         if (flags & NDR_OUT) {
19147                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
19148                 ndr->depth++;
19149                 ndr_print_WERROR(ndr, "result", r->out.result);
19150                 ndr->depth--;
19151         }
19152         ndr->depth--;
19153 }
19154
19155 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
19156 {
19157         if (flags & NDR_IN) {
19158         }
19159         if (flags & NDR_OUT) {
19160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19161         }
19162         return NDR_ERR_SUCCESS;
19163 }
19164
19165 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
19166 {
19167         if (flags & NDR_IN) {
19168         }
19169         if (flags & NDR_OUT) {
19170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19171         }
19172         return NDR_ERR_SUCCESS;
19173 }
19174
19175 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
19176 {
19177         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
19178         ndr->depth++;
19179         if (flags & NDR_SET_VALUES) {
19180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19181         }
19182         if (flags & NDR_IN) {
19183                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
19184                 ndr->depth++;
19185                 ndr->depth--;
19186         }
19187         if (flags & NDR_OUT) {
19188                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
19189                 ndr->depth++;
19190                 ndr_print_WERROR(ndr, "result", r->out.result);
19191                 ndr->depth--;
19192         }
19193         ndr->depth--;
19194 }
19195
19196 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
19197 {
19198         if (flags & NDR_IN) {
19199         }
19200         if (flags & NDR_OUT) {
19201                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19202         }
19203         return NDR_ERR_SUCCESS;
19204 }
19205
19206 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
19207 {
19208         if (flags & NDR_IN) {
19209         }
19210         if (flags & NDR_OUT) {
19211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19212         }
19213         return NDR_ERR_SUCCESS;
19214 }
19215
19216 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
19217 {
19218         ndr_print_struct(ndr, name, "spoolss_DeletePort");
19219         ndr->depth++;
19220         if (flags & NDR_SET_VALUES) {
19221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19222         }
19223         if (flags & NDR_IN) {
19224                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
19225                 ndr->depth++;
19226                 ndr->depth--;
19227         }
19228         if (flags & NDR_OUT) {
19229                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
19230                 ndr->depth++;
19231                 ndr_print_WERROR(ndr, "result", r->out.result);
19232                 ndr->depth--;
19233         }
19234         ndr->depth--;
19235 }
19236
19237 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
19238 {
19239         if (flags & NDR_IN) {
19240         }
19241         if (flags & NDR_OUT) {
19242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19243         }
19244         return NDR_ERR_SUCCESS;
19245 }
19246
19247 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
19248 {
19249         if (flags & NDR_IN) {
19250         }
19251         if (flags & NDR_OUT) {
19252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19253         }
19254         return NDR_ERR_SUCCESS;
19255 }
19256
19257 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
19258 {
19259         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
19260         ndr->depth++;
19261         if (flags & NDR_SET_VALUES) {
19262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19263         }
19264         if (flags & NDR_IN) {
19265                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
19266                 ndr->depth++;
19267                 ndr->depth--;
19268         }
19269         if (flags & NDR_OUT) {
19270                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
19271                 ndr->depth++;
19272                 ndr_print_WERROR(ndr, "result", r->out.result);
19273                 ndr->depth--;
19274         }
19275         ndr->depth--;
19276 }
19277
19278 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19279 {
19280         if (flags & NDR_IN) {
19281         }
19282         if (flags & NDR_OUT) {
19283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19284         }
19285         return NDR_ERR_SUCCESS;
19286 }
19287
19288 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
19289 {
19290         if (flags & NDR_IN) {
19291         }
19292         if (flags & NDR_OUT) {
19293                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19294         }
19295         return NDR_ERR_SUCCESS;
19296 }
19297
19298 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19299 {
19300         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
19301         ndr->depth++;
19302         if (flags & NDR_SET_VALUES) {
19303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19304         }
19305         if (flags & NDR_IN) {
19306                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
19307                 ndr->depth++;
19308                 ndr->depth--;
19309         }
19310         if (flags & NDR_OUT) {
19311                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
19312                 ndr->depth++;
19313                 ndr_print_WERROR(ndr, "result", r->out.result);
19314                 ndr->depth--;
19315         }
19316         ndr->depth--;
19317 }
19318
19319 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
19320 {
19321         if (flags & NDR_IN) {
19322         }
19323         if (flags & NDR_OUT) {
19324                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19325         }
19326         return NDR_ERR_SUCCESS;
19327 }
19328
19329 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
19330 {
19331         if (flags & NDR_IN) {
19332         }
19333         if (flags & NDR_OUT) {
19334                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19335         }
19336         return NDR_ERR_SUCCESS;
19337 }
19338
19339 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
19340 {
19341         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
19342         ndr->depth++;
19343         if (flags & NDR_SET_VALUES) {
19344                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19345         }
19346         if (flags & NDR_IN) {
19347                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
19348                 ndr->depth++;
19349                 ndr->depth--;
19350         }
19351         if (flags & NDR_OUT) {
19352                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
19353                 ndr->depth++;
19354                 ndr_print_WERROR(ndr, "result", r->out.result);
19355                 ndr->depth--;
19356         }
19357         ndr->depth--;
19358 }
19359
19360 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
19361 {
19362         if (flags & NDR_IN) {
19363         }
19364         if (flags & NDR_OUT) {
19365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19366         }
19367         return NDR_ERR_SUCCESS;
19368 }
19369
19370 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
19371 {
19372         if (flags & NDR_IN) {
19373         }
19374         if (flags & NDR_OUT) {
19375                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19376         }
19377         return NDR_ERR_SUCCESS;
19378 }
19379
19380 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
19381 {
19382         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
19383         ndr->depth++;
19384         if (flags & NDR_SET_VALUES) {
19385                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19386         }
19387         if (flags & NDR_IN) {
19388                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
19389                 ndr->depth++;
19390                 ndr->depth--;
19391         }
19392         if (flags & NDR_OUT) {
19393                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
19394                 ndr->depth++;
19395                 ndr_print_WERROR(ndr, "result", r->out.result);
19396                 ndr->depth--;
19397         }
19398         ndr->depth--;
19399 }
19400
19401 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
19402 {
19403         if (flags & NDR_IN) {
19404         }
19405         if (flags & NDR_OUT) {
19406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19407         }
19408         return NDR_ERR_SUCCESS;
19409 }
19410
19411 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
19412 {
19413         if (flags & NDR_IN) {
19414         }
19415         if (flags & NDR_OUT) {
19416                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19417         }
19418         return NDR_ERR_SUCCESS;
19419 }
19420
19421 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
19422 {
19423         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
19424         ndr->depth++;
19425         if (flags & NDR_SET_VALUES) {
19426                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19427         }
19428         if (flags & NDR_IN) {
19429                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
19430                 ndr->depth++;
19431                 ndr->depth--;
19432         }
19433         if (flags & NDR_OUT) {
19434                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
19435                 ndr->depth++;
19436                 ndr_print_WERROR(ndr, "result", r->out.result);
19437                 ndr->depth--;
19438         }
19439         ndr->depth--;
19440 }
19441
19442 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
19443 {
19444         if (flags & NDR_IN) {
19445         }
19446         if (flags & NDR_OUT) {
19447                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19448         }
19449         return NDR_ERR_SUCCESS;
19450 }
19451
19452 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
19453 {
19454         if (flags & NDR_IN) {
19455         }
19456         if (flags & NDR_OUT) {
19457                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19458         }
19459         return NDR_ERR_SUCCESS;
19460 }
19461
19462 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
19463 {
19464         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
19465         ndr->depth++;
19466         if (flags & NDR_SET_VALUES) {
19467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19468         }
19469         if (flags & NDR_IN) {
19470                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
19471                 ndr->depth++;
19472                 ndr->depth--;
19473         }
19474         if (flags & NDR_OUT) {
19475                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
19476                 ndr->depth++;
19477                 ndr_print_WERROR(ndr, "result", r->out.result);
19478                 ndr->depth--;
19479         }
19480         ndr->depth--;
19481 }
19482
19483 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
19484 {
19485         if (flags & NDR_IN) {
19486         }
19487         if (flags & NDR_OUT) {
19488                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19489         }
19490         return NDR_ERR_SUCCESS;
19491 }
19492
19493 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
19494 {
19495         if (flags & NDR_IN) {
19496         }
19497         if (flags & NDR_OUT) {
19498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19499         }
19500         return NDR_ERR_SUCCESS;
19501 }
19502
19503 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
19504 {
19505         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
19506         ndr->depth++;
19507         if (flags & NDR_SET_VALUES) {
19508                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19509         }
19510         if (flags & NDR_IN) {
19511                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
19512                 ndr->depth++;
19513                 ndr->depth--;
19514         }
19515         if (flags & NDR_OUT) {
19516                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
19517                 ndr->depth++;
19518                 ndr_print_WERROR(ndr, "result", r->out.result);
19519                 ndr->depth--;
19520         }
19521         ndr->depth--;
19522 }
19523
19524 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
19525 {
19526         if (flags & NDR_IN) {
19527         }
19528         if (flags & NDR_OUT) {
19529                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19530         }
19531         return NDR_ERR_SUCCESS;
19532 }
19533
19534 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
19535 {
19536         if (flags & NDR_IN) {
19537         }
19538         if (flags & NDR_OUT) {
19539                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19540         }
19541         return NDR_ERR_SUCCESS;
19542 }
19543
19544 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
19545 {
19546         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
19547         ndr->depth++;
19548         if (flags & NDR_SET_VALUES) {
19549                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19550         }
19551         if (flags & NDR_IN) {
19552                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
19553                 ndr->depth++;
19554                 ndr->depth--;
19555         }
19556         if (flags & NDR_OUT) {
19557                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
19558                 ndr->depth++;
19559                 ndr_print_WERROR(ndr, "result", r->out.result);
19560                 ndr->depth--;
19561         }
19562         ndr->depth--;
19563 }
19564
19565 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
19566 {
19567         if (flags & NDR_IN) {
19568         }
19569         if (flags & NDR_OUT) {
19570                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19571         }
19572         return NDR_ERR_SUCCESS;
19573 }
19574
19575 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
19576 {
19577         if (flags & NDR_IN) {
19578         }
19579         if (flags & NDR_OUT) {
19580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19581         }
19582         return NDR_ERR_SUCCESS;
19583 }
19584
19585 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
19586 {
19587         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
19588         ndr->depth++;
19589         if (flags & NDR_SET_VALUES) {
19590                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19591         }
19592         if (flags & NDR_IN) {
19593                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
19594                 ndr->depth++;
19595                 ndr->depth--;
19596         }
19597         if (flags & NDR_OUT) {
19598                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
19599                 ndr->depth++;
19600                 ndr_print_WERROR(ndr, "result", r->out.result);
19601                 ndr->depth--;
19602         }
19603         ndr->depth--;
19604 }
19605
19606 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
19607 {
19608         if (flags & NDR_IN) {
19609         }
19610         if (flags & NDR_OUT) {
19611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19612         }
19613         return NDR_ERR_SUCCESS;
19614 }
19615
19616 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
19617 {
19618         if (flags & NDR_IN) {
19619         }
19620         if (flags & NDR_OUT) {
19621                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19622         }
19623         return NDR_ERR_SUCCESS;
19624 }
19625
19626 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
19627 {
19628         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
19629         ndr->depth++;
19630         if (flags & NDR_SET_VALUES) {
19631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19632         }
19633         if (flags & NDR_IN) {
19634                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
19635                 ndr->depth++;
19636                 ndr->depth--;
19637         }
19638         if (flags & NDR_OUT) {
19639                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
19640                 ndr->depth++;
19641                 ndr_print_WERROR(ndr, "result", r->out.result);
19642                 ndr->depth--;
19643         }
19644         ndr->depth--;
19645 }
19646
19647 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
19648 {
19649         if (flags & NDR_IN) {
19650         }
19651         if (flags & NDR_OUT) {
19652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19653         }
19654         return NDR_ERR_SUCCESS;
19655 }
19656
19657 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
19658 {
19659         if (flags & NDR_IN) {
19660         }
19661         if (flags & NDR_OUT) {
19662                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19663         }
19664         return NDR_ERR_SUCCESS;
19665 }
19666
19667 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
19668 {
19669         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
19670         ndr->depth++;
19671         if (flags & NDR_SET_VALUES) {
19672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19673         }
19674         if (flags & NDR_IN) {
19675                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
19676                 ndr->depth++;
19677                 ndr->depth--;
19678         }
19679         if (flags & NDR_OUT) {
19680                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
19681                 ndr->depth++;
19682                 ndr_print_WERROR(ndr, "result", r->out.result);
19683                 ndr->depth--;
19684         }
19685         ndr->depth--;
19686 }
19687
19688 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19689 {
19690         if (flags & NDR_IN) {
19691         }
19692         if (flags & NDR_OUT) {
19693                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19694         }
19695         return NDR_ERR_SUCCESS;
19696 }
19697
19698 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
19699 {
19700         if (flags & NDR_IN) {
19701         }
19702         if (flags & NDR_OUT) {
19703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19704         }
19705         return NDR_ERR_SUCCESS;
19706 }
19707
19708 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19709 {
19710         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
19711         ndr->depth++;
19712         if (flags & NDR_SET_VALUES) {
19713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19714         }
19715         if (flags & NDR_IN) {
19716                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
19717                 ndr->depth++;
19718                 ndr->depth--;
19719         }
19720         if (flags & NDR_OUT) {
19721                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
19722                 ndr->depth++;
19723                 ndr_print_WERROR(ndr, "result", r->out.result);
19724                 ndr->depth--;
19725         }
19726         ndr->depth--;
19727 }
19728
19729 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
19730 {
19731         if (flags & NDR_IN) {
19732                 if (r->in.handle == NULL) {
19733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19734                 }
19735                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
19737                 if (r->in.data_type) {
19738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19741                         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));
19742                 }
19743                 if (r->in.devmode_ctr == NULL) {
19744                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19745                 }
19746                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19747         }
19748         if (flags & NDR_OUT) {
19749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19750         }
19751         return NDR_ERR_SUCCESS;
19752 }
19753
19754 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
19755 {
19756         uint32_t _ptr_data_type;
19757         TALLOC_CTX *_mem_save_handle_0;
19758         TALLOC_CTX *_mem_save_data_type_0;
19759         TALLOC_CTX *_mem_save_devmode_ctr_0;
19760         if (flags & NDR_IN) {
19761                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19762                         NDR_PULL_ALLOC(ndr, r->in.handle);
19763                 }
19764                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19765                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19766                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19767                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
19769                 if (_ptr_data_type) {
19770                         NDR_PULL_ALLOC(ndr, r->in.data_type);
19771                 } else {
19772                         r->in.data_type = NULL;
19773                 }
19774                 if (r->in.data_type) {
19775                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
19776                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
19777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
19778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
19779                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
19780                                 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));
19781                         }
19782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
19783                         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));
19784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
19785                 }
19786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19787                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19788                 }
19789                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19791                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19793         }
19794         if (flags & NDR_OUT) {
19795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19796         }
19797         return NDR_ERR_SUCCESS;
19798 }
19799
19800 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
19801 {
19802         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
19803         ndr->depth++;
19804         if (flags & NDR_SET_VALUES) {
19805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19806         }
19807         if (flags & NDR_IN) {
19808                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
19809                 ndr->depth++;
19810                 ndr_print_ptr(ndr, "handle", r->in.handle);
19811                 ndr->depth++;
19812                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19813                 ndr->depth--;
19814                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
19815                 ndr->depth++;
19816                 if (r->in.data_type) {
19817                         ndr_print_string(ndr, "data_type", r->in.data_type);
19818                 }
19819                 ndr->depth--;
19820                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19821                 ndr->depth++;
19822                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19823                 ndr->depth--;
19824                 ndr->depth--;
19825         }
19826         if (flags & NDR_OUT) {
19827                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
19828                 ndr->depth++;
19829                 ndr_print_WERROR(ndr, "result", r->out.result);
19830                 ndr->depth--;
19831         }
19832         ndr->depth--;
19833 }
19834
19835 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
19836 {
19837         if (flags & NDR_IN) {
19838                 if (r->in.handle == NULL) {
19839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19840                 }
19841                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
19843                 if (r->in.architecture) {
19844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19848                 }
19849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19851                 if (r->in.buffer) {
19852                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19853                 }
19854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
19856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
19857         }
19858         if (flags & NDR_OUT) {
19859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19860                 if (r->out.info) {
19861                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19862                 }
19863                 if (r->out.needed == NULL) {
19864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19865                 }
19866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19867                 if (r->out.server_major_version == NULL) {
19868                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19869                 }
19870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
19871                 if (r->out.server_minor_version == NULL) {
19872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19873                 }
19874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
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_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
19881 {
19882         uint32_t _ptr_architecture;
19883         uint32_t _ptr_buffer;
19884         uint32_t _ptr_info;
19885         TALLOC_CTX *_mem_save_handle_0;
19886         TALLOC_CTX *_mem_save_architecture_0;
19887         TALLOC_CTX *_mem_save_buffer_0;
19888         TALLOC_CTX *_mem_save_info_0;
19889         TALLOC_CTX *_mem_save_needed_0;
19890         TALLOC_CTX *_mem_save_server_major_version_0;
19891         TALLOC_CTX *_mem_save_server_minor_version_0;
19892         if (flags & NDR_IN) {
19893                 ZERO_STRUCT(r->out);
19894
19895                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19896                         NDR_PULL_ALLOC(ndr, r->in.handle);
19897                 }
19898                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19899                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19900                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
19903                 if (_ptr_architecture) {
19904                         NDR_PULL_ALLOC(ndr, r->in.architecture);
19905                 } else {
19906                         r->in.architecture = NULL;
19907                 }
19908                 if (r->in.architecture) {
19909                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
19910                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
19911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
19912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
19913                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
19914                                 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));
19915                         }
19916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
19917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
19918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
19919                 }
19920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19922                 if (_ptr_buffer) {
19923                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19924                 } else {
19925                         r->in.buffer = NULL;
19926                 }
19927                 if (r->in.buffer) {
19928                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19929                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19930                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19932                 }
19933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
19935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
19936                 NDR_PULL_ALLOC(ndr, r->out.needed);
19937                 ZERO_STRUCTP(r->out.needed);
19938                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19939                 ZERO_STRUCTP(r->out.server_major_version);
19940                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19941                 ZERO_STRUCTP(r->out.server_minor_version);
19942         }
19943         if (flags & NDR_OUT) {
19944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19945                 if (_ptr_info) {
19946                         NDR_PULL_ALLOC(ndr, r->out.info);
19947                 } else {
19948                         r->out.info = NULL;
19949                 }
19950                 if (r->out.info) {
19951                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19952                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19953                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19955                 }
19956                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19957                         NDR_PULL_ALLOC(ndr, r->out.needed);
19958                 }
19959                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19960                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19964                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19965                 }
19966                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19967                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
19968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
19969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
19970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19971                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19972                 }
19973                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19974                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
19975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
19976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
19977                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19978         }
19979         return NDR_ERR_SUCCESS;
19980 }
19981
19982 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
19983 {
19984         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
19985         ndr->depth++;
19986         if (flags & NDR_SET_VALUES) {
19987                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19988         }
19989         if (flags & NDR_IN) {
19990                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
19991                 ndr->depth++;
19992                 ndr_print_ptr(ndr, "handle", r->in.handle);
19993                 ndr->depth++;
19994                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19995                 ndr->depth--;
19996                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
19997                 ndr->depth++;
19998                 if (r->in.architecture) {
19999                         ndr_print_string(ndr, "architecture", r->in.architecture);
20000                 }
20001                 ndr->depth--;
20002                 ndr_print_uint32(ndr, "level", r->in.level);
20003                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20004                 ndr->depth++;
20005                 if (r->in.buffer) {
20006                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20007                 }
20008                 ndr->depth--;
20009                 ndr_print_uint32(ndr, "offered", r->in.offered);
20010                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
20011                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
20012                 ndr->depth--;
20013         }
20014         if (flags & NDR_OUT) {
20015                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
20016                 ndr->depth++;
20017                 ndr_print_ptr(ndr, "info", r->out.info);
20018                 ndr->depth++;
20019                 if (r->out.info) {
20020                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
20021                 }
20022                 ndr->depth--;
20023                 ndr_print_ptr(ndr, "needed", r->out.needed);
20024                 ndr->depth++;
20025                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20026                 ndr->depth--;
20027                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
20028                 ndr->depth++;
20029                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
20030                 ndr->depth--;
20031                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
20032                 ndr->depth++;
20033                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
20034                 ndr->depth--;
20035                 ndr_print_WERROR(ndr, "result", r->out.result);
20036                 ndr->depth--;
20037         }
20038         ndr->depth--;
20039 }
20040
20041 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20042 {
20043         if (flags & NDR_IN) {
20044         }
20045         if (flags & NDR_OUT) {
20046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20047         }
20048         return NDR_ERR_SUCCESS;
20049 }
20050
20051 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
20052 {
20053         if (flags & NDR_IN) {
20054         }
20055         if (flags & NDR_OUT) {
20056                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20057         }
20058         return NDR_ERR_SUCCESS;
20059 }
20060
20061 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20062 {
20063         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
20064         ndr->depth++;
20065         if (flags & NDR_SET_VALUES) {
20066                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20067         }
20068         if (flags & NDR_IN) {
20069                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
20070                 ndr->depth++;
20071                 ndr->depth--;
20072         }
20073         if (flags & NDR_OUT) {
20074                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
20075                 ndr->depth++;
20076                 ndr_print_WERROR(ndr, "result", r->out.result);
20077                 ndr->depth--;
20078         }
20079         ndr->depth--;
20080 }
20081
20082 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20083 {
20084         if (flags & NDR_IN) {
20085         }
20086         if (flags & NDR_OUT) {
20087                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20088         }
20089         return NDR_ERR_SUCCESS;
20090 }
20091
20092 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
20093 {
20094         if (flags & NDR_IN) {
20095         }
20096         if (flags & NDR_OUT) {
20097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20098         }
20099         return NDR_ERR_SUCCESS;
20100 }
20101
20102 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20103 {
20104         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
20105         ndr->depth++;
20106         if (flags & NDR_SET_VALUES) {
20107                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20108         }
20109         if (flags & NDR_IN) {
20110                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
20111                 ndr->depth++;
20112                 ndr->depth--;
20113         }
20114         if (flags & NDR_OUT) {
20115                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
20116                 ndr->depth++;
20117                 ndr_print_WERROR(ndr, "result", r->out.result);
20118                 ndr->depth--;
20119         }
20120         ndr->depth--;
20121 }
20122
20123 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
20124 {
20125         if (flags & NDR_IN) {
20126                 if (r->in.handle == NULL) {
20127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20128                 }
20129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20130         }
20131         if (flags & NDR_OUT) {
20132                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20133         }
20134         return NDR_ERR_SUCCESS;
20135 }
20136
20137 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
20138 {
20139         TALLOC_CTX *_mem_save_handle_0;
20140         if (flags & NDR_IN) {
20141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20142                         NDR_PULL_ALLOC(ndr, r->in.handle);
20143                 }
20144                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20145                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20146                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20148         }
20149         if (flags & NDR_OUT) {
20150                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20151         }
20152         return NDR_ERR_SUCCESS;
20153 }
20154
20155 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
20156 {
20157         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
20158         ndr->depth++;
20159         if (flags & NDR_SET_VALUES) {
20160                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20161         }
20162         if (flags & NDR_IN) {
20163                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
20164                 ndr->depth++;
20165                 ndr_print_ptr(ndr, "handle", r->in.handle);
20166                 ndr->depth++;
20167                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20168                 ndr->depth--;
20169                 ndr->depth--;
20170         }
20171         if (flags & NDR_OUT) {
20172                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
20173                 ndr->depth++;
20174                 ndr_print_WERROR(ndr, "result", r->out.result);
20175                 ndr->depth--;
20176         }
20177         ndr->depth--;
20178 }
20179
20180 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20181 {
20182         if (flags & NDR_IN) {
20183         }
20184         if (flags & NDR_OUT) {
20185                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20186         }
20187         return NDR_ERR_SUCCESS;
20188 }
20189
20190 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20191 {
20192         if (flags & NDR_IN) {
20193         }
20194         if (flags & NDR_OUT) {
20195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20196         }
20197         return NDR_ERR_SUCCESS;
20198 }
20199
20200 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20201 {
20202         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20203         ndr->depth++;
20204         if (flags & NDR_SET_VALUES) {
20205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20206         }
20207         if (flags & NDR_IN) {
20208                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20209                 ndr->depth++;
20210                 ndr->depth--;
20211         }
20212         if (flags & NDR_OUT) {
20213                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20214                 ndr->depth++;
20215                 ndr_print_WERROR(ndr, "result", r->out.result);
20216                 ndr->depth--;
20217         }
20218         ndr->depth--;
20219 }
20220
20221 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
20222 {
20223         if (flags & NDR_IN) {
20224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20227                 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));
20228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20229                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
20230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20232                 if (r->in.buffer) {
20233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20234                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20235                 }
20236         }
20237         if (flags & NDR_OUT) {
20238                 if (r->out.handle == NULL) {
20239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20240                 }
20241                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20243         }
20244         return NDR_ERR_SUCCESS;
20245 }
20246
20247 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
20248 {
20249         uint32_t _ptr_buffer;
20250         TALLOC_CTX *_mem_save_buffer_0;
20251         TALLOC_CTX *_mem_save_handle_0;
20252         if (flags & NDR_IN) {
20253                 ZERO_STRUCT(r->out);
20254
20255                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
20256                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
20257                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
20258                         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));
20259                 }
20260                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
20261                 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));
20262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20263                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
20264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20265                 if (r->in.bufsize > 512) {
20266                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20267                 }
20268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20269                 if (_ptr_buffer) {
20270                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20271                 } else {
20272                         r->in.buffer = NULL;
20273                 }
20274                 if (r->in.buffer) {
20275                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20276                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20277                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20278                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20279                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20281                 }
20282                 NDR_PULL_ALLOC(ndr, r->out.handle);
20283                 ZERO_STRUCTP(r->out.handle);
20284                 if (r->in.buffer) {
20285                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20286                 }
20287         }
20288         if (flags & NDR_OUT) {
20289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20290                         NDR_PULL_ALLOC(ndr, r->out.handle);
20291                 }
20292                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20293                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20294                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20296                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20297         }
20298         return NDR_ERR_SUCCESS;
20299 }
20300
20301 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
20302 {
20303         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
20304         ndr->depth++;
20305         if (flags & NDR_SET_VALUES) {
20306                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20307         }
20308         if (flags & NDR_IN) {
20309                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
20310                 ndr->depth++;
20311                 ndr_print_string(ndr, "server_name", r->in.server_name);
20312                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20313                 ndr_print_winreg_Type(ndr, "type", r->in.type);
20314                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20315                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20316                 ndr->depth++;
20317                 if (r->in.buffer) {
20318                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20319                 }
20320                 ndr->depth--;
20321                 ndr->depth--;
20322         }
20323         if (flags & NDR_OUT) {
20324                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
20325                 ndr->depth++;
20326                 ndr_print_ptr(ndr, "handle", r->out.handle);
20327                 ndr->depth++;
20328                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20329                 ndr->depth--;
20330                 ndr_print_WERROR(ndr, "result", r->out.result);
20331                 ndr->depth--;
20332         }
20333         ndr->depth--;
20334 }
20335
20336 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
20337 {
20338         if (flags & NDR_IN) {
20339                 if (r->in.handle == NULL) {
20340                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20341                 }
20342                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20343                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20346                 if (r->in.buffer) {
20347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20348                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20349                 }
20350         }
20351         if (flags & NDR_OUT) {
20352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20353         }
20354         return NDR_ERR_SUCCESS;
20355 }
20356
20357 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
20358 {
20359         uint32_t _ptr_buffer;
20360         TALLOC_CTX *_mem_save_handle_0;
20361         TALLOC_CTX *_mem_save_buffer_0;
20362         if (flags & NDR_IN) {
20363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20364                         NDR_PULL_ALLOC(ndr, r->in.handle);
20365                 }
20366                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20370                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20372                 if (r->in.bufsize > 512) {
20373                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20374                 }
20375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20376                 if (_ptr_buffer) {
20377                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20378                 } else {
20379                         r->in.buffer = NULL;
20380                 }
20381                 if (r->in.buffer) {
20382                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20383                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20385                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20386                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20388                 }
20389                 if (r->in.buffer) {
20390                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20391                 }
20392         }
20393         if (flags & NDR_OUT) {
20394                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20395         }
20396         return NDR_ERR_SUCCESS;
20397 }
20398
20399 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
20400 {
20401         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
20402         ndr->depth++;
20403         if (flags & NDR_SET_VALUES) {
20404                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20405         }
20406         if (flags & NDR_IN) {
20407                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
20408                 ndr->depth++;
20409                 ndr_print_ptr(ndr, "handle", r->in.handle);
20410                 ndr->depth++;
20411                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20412                 ndr->depth--;
20413                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20414                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20415                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20416                 ndr->depth++;
20417                 if (r->in.buffer) {
20418                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20419                 }
20420                 ndr->depth--;
20421                 ndr->depth--;
20422         }
20423         if (flags & NDR_OUT) {
20424                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
20425                 ndr->depth++;
20426                 ndr_print_WERROR(ndr, "result", r->out.result);
20427                 ndr->depth--;
20428         }
20429         ndr->depth--;
20430 }
20431
20432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
20433 {
20434         if (flags & NDR_IN) {
20435                 if (r->in.handle == NULL) {
20436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20437                 }
20438                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20439         }
20440         if (flags & NDR_OUT) {
20441                 if (r->out.handle == NULL) {
20442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20443                 }
20444                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20446         }
20447         return NDR_ERR_SUCCESS;
20448 }
20449
20450 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
20451 {
20452         TALLOC_CTX *_mem_save_handle_0;
20453         if (flags & NDR_IN) {
20454                 ZERO_STRUCT(r->out);
20455
20456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20457                         NDR_PULL_ALLOC(ndr, r->in.handle);
20458                 }
20459                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20460                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20461                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20463                 NDR_PULL_ALLOC(ndr, r->out.handle);
20464                 *r->out.handle = *r->in.handle;
20465         }
20466         if (flags & NDR_OUT) {
20467                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20468                         NDR_PULL_ALLOC(ndr, r->out.handle);
20469                 }
20470                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20471                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20472                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20474                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20475         }
20476         return NDR_ERR_SUCCESS;
20477 }
20478
20479 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
20480 {
20481         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
20482         ndr->depth++;
20483         if (flags & NDR_SET_VALUES) {
20484                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20485         }
20486         if (flags & NDR_IN) {
20487                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
20488                 ndr->depth++;
20489                 ndr_print_ptr(ndr, "handle", r->in.handle);
20490                 ndr->depth++;
20491                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20492                 ndr->depth--;
20493                 ndr->depth--;
20494         }
20495         if (flags & NDR_OUT) {
20496                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
20497                 ndr->depth++;
20498                 ndr_print_ptr(ndr, "handle", r->out.handle);
20499                 ndr->depth++;
20500                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20501                 ndr->depth--;
20502                 ndr_print_WERROR(ndr, "result", r->out.result);
20503                 ndr->depth--;
20504         }
20505         ndr->depth--;
20506 }
20507
20508 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
20509 {
20510         if (flags & NDR_IN) {
20511         }
20512         if (flags & NDR_OUT) {
20513                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20514         }
20515         return NDR_ERR_SUCCESS;
20516 }
20517
20518 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
20519 {
20520         if (flags & NDR_IN) {
20521         }
20522         if (flags & NDR_OUT) {
20523                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20524         }
20525         return NDR_ERR_SUCCESS;
20526 }
20527
20528 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
20529 {
20530         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
20531         ndr->depth++;
20532         if (flags & NDR_SET_VALUES) {
20533                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20534         }
20535         if (flags & NDR_IN) {
20536                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
20537                 ndr->depth++;
20538                 ndr->depth--;
20539         }
20540         if (flags & NDR_OUT) {
20541                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
20542                 ndr->depth++;
20543                 ndr_print_WERROR(ndr, "result", r->out.result);
20544                 ndr->depth--;
20545         }
20546         ndr->depth--;
20547 }
20548
20549 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20550 {
20551         if (flags & NDR_IN) {
20552         }
20553         if (flags & NDR_OUT) {
20554                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20555         }
20556         return NDR_ERR_SUCCESS;
20557 }
20558
20559 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20560 {
20561         if (flags & NDR_IN) {
20562         }
20563         if (flags & NDR_OUT) {
20564                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20565         }
20566         return NDR_ERR_SUCCESS;
20567 }
20568
20569 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20570 {
20571         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
20572         ndr->depth++;
20573         if (flags & NDR_SET_VALUES) {
20574                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20575         }
20576         if (flags & NDR_IN) {
20577                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
20578                 ndr->depth++;
20579                 ndr->depth--;
20580         }
20581         if (flags & NDR_OUT) {
20582                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
20583                 ndr->depth++;
20584                 ndr_print_WERROR(ndr, "result", r->out.result);
20585                 ndr->depth--;
20586         }
20587         ndr->depth--;
20588 }
20589
20590 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
20591 {
20592         if (flags & NDR_IN) {
20593         }
20594         if (flags & NDR_OUT) {
20595                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20596         }
20597         return NDR_ERR_SUCCESS;
20598 }
20599
20600 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
20601 {
20602         if (flags & NDR_IN) {
20603         }
20604         if (flags & NDR_OUT) {
20605                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20606         }
20607         return NDR_ERR_SUCCESS;
20608 }
20609
20610 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
20611 {
20612         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
20613         ndr->depth++;
20614         if (flags & NDR_SET_VALUES) {
20615                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20616         }
20617         if (flags & NDR_IN) {
20618                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
20619                 ndr->depth++;
20620                 ndr->depth--;
20621         }
20622         if (flags & NDR_OUT) {
20623                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
20624                 ndr->depth++;
20625                 ndr_print_WERROR(ndr, "result", r->out.result);
20626                 ndr->depth--;
20627         }
20628         ndr->depth--;
20629 }
20630
20631 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
20632 {
20633         if (flags & NDR_IN) {
20634         }
20635         if (flags & NDR_OUT) {
20636                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20637         }
20638         return NDR_ERR_SUCCESS;
20639 }
20640
20641 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
20642 {
20643         if (flags & NDR_IN) {
20644         }
20645         if (flags & NDR_OUT) {
20646                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20647         }
20648         return NDR_ERR_SUCCESS;
20649 }
20650
20651 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
20652 {
20653         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
20654         ndr->depth++;
20655         if (flags & NDR_SET_VALUES) {
20656                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20657         }
20658         if (flags & NDR_IN) {
20659                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
20660                 ndr->depth++;
20661                 ndr->depth--;
20662         }
20663         if (flags & NDR_OUT) {
20664                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
20665                 ndr->depth++;
20666                 ndr_print_WERROR(ndr, "result", r->out.result);
20667                 ndr->depth--;
20668         }
20669         ndr->depth--;
20670 }
20671
20672 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20673 {
20674         if (flags & NDR_IN) {
20675                 if (r->in.handle == NULL) {
20676                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20677                 }
20678                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20679                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
20681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
20682                 if (r->in.local_machine) {
20683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20686                         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));
20687                 }
20688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
20690                 if (r->in.notify_options) {
20691                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20692                 }
20693         }
20694         if (flags & NDR_OUT) {
20695                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20696         }
20697         return NDR_ERR_SUCCESS;
20698 }
20699
20700 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20701 {
20702         uint32_t _ptr_local_machine;
20703         uint32_t _ptr_notify_options;
20704         TALLOC_CTX *_mem_save_handle_0;
20705         TALLOC_CTX *_mem_save_local_machine_0;
20706         TALLOC_CTX *_mem_save_notify_options_0;
20707         if (flags & NDR_IN) {
20708                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20709                         NDR_PULL_ALLOC(ndr, r->in.handle);
20710                 }
20711                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20712                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20713                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20715                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
20717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
20718                 if (_ptr_local_machine) {
20719                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
20720                 } else {
20721                         r->in.local_machine = NULL;
20722                 }
20723                 if (r->in.local_machine) {
20724                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
20725                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
20726                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
20727                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
20728                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
20729                                 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));
20730                         }
20731                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
20732                         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));
20733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
20734                 }
20735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
20737                 if (_ptr_notify_options) {
20738                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
20739                 } else {
20740                         r->in.notify_options = NULL;
20741                 }
20742                 if (r->in.notify_options) {
20743                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20744                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
20745                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
20747                 }
20748         }
20749         if (flags & NDR_OUT) {
20750                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20751         }
20752         return NDR_ERR_SUCCESS;
20753 }
20754
20755 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20756 {
20757         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20758         ndr->depth++;
20759         if (flags & NDR_SET_VALUES) {
20760                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20761         }
20762         if (flags & NDR_IN) {
20763                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20764                 ndr->depth++;
20765                 ndr_print_ptr(ndr, "handle", r->in.handle);
20766                 ndr->depth++;
20767                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20768                 ndr->depth--;
20769                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20770                 ndr_print_uint32(ndr, "options", r->in.options);
20771                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
20772                 ndr->depth++;
20773                 if (r->in.local_machine) {
20774                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
20775                 }
20776                 ndr->depth--;
20777                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20778                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
20779                 ndr->depth++;
20780                 if (r->in.notify_options) {
20781                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
20782                 }
20783                 ndr->depth--;
20784                 ndr->depth--;
20785         }
20786         if (flags & NDR_OUT) {
20787                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20788                 ndr->depth++;
20789                 ndr_print_WERROR(ndr, "result", r->out.result);
20790                 ndr->depth--;
20791         }
20792         ndr->depth--;
20793 }
20794
20795 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20796 {
20797         if (flags & NDR_IN) {
20798                 if (r->in.handle == NULL) {
20799                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20800                 }
20801                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
20803                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
20805                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20806                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20807         }
20808         if (flags & NDR_OUT) {
20809                 if (r->out.reply_result == NULL) {
20810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20811                 }
20812                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
20813                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20814         }
20815         return NDR_ERR_SUCCESS;
20816 }
20817
20818 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
20819 {
20820         TALLOC_CTX *_mem_save_handle_0;
20821         TALLOC_CTX *_mem_save_reply_result_0;
20822         if (flags & NDR_IN) {
20823                 ZERO_STRUCT(r->out);
20824
20825                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20826                         NDR_PULL_ALLOC(ndr, r->in.handle);
20827                 }
20828                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20829                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20830                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20831                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
20833                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
20835                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20836                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20837                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
20838                 ZERO_STRUCTP(r->out.reply_result);
20839         }
20840         if (flags & NDR_OUT) {
20841                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20842                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
20843                 }
20844                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
20845                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
20846                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
20847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
20848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20849         }
20850         return NDR_ERR_SUCCESS;
20851 }
20852
20853 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20854 {
20855         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
20856         ndr->depth++;
20857         if (flags & NDR_SET_VALUES) {
20858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20859         }
20860         if (flags & NDR_IN) {
20861                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
20862                 ndr->depth++;
20863                 ndr_print_ptr(ndr, "handle", r->in.handle);
20864                 ndr->depth++;
20865                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20866                 ndr->depth--;
20867                 ndr_print_uint32(ndr, "color", r->in.color);
20868                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20869                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
20870                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
20871                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
20872                 ndr->depth--;
20873         }
20874         if (flags & NDR_OUT) {
20875                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
20876                 ndr->depth++;
20877                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
20878                 ndr->depth++;
20879                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
20880                 ndr->depth--;
20881                 ndr_print_WERROR(ndr, "result", r->out.result);
20882                 ndr->depth--;
20883         }
20884         ndr->depth--;
20885 }
20886
20887 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20888 {
20889         if (flags & NDR_IN) {
20890                 if (r->in.handle == NULL) {
20891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20892                 }
20893                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
20895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
20896                 if (r->in.options) {
20897                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20898                 }
20899         }
20900         if (flags & NDR_OUT) {
20901                 if (r->out.info == NULL) {
20902                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20903                 }
20904                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
20905                 if (*r->out.info) {
20906                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20907                 }
20908                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20909         }
20910         return NDR_ERR_SUCCESS;
20911 }
20912
20913 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
20914 {
20915         uint32_t _ptr_options;
20916         uint32_t _ptr_info;
20917         TALLOC_CTX *_mem_save_handle_0;
20918         TALLOC_CTX *_mem_save_options_0;
20919         TALLOC_CTX *_mem_save_info_0;
20920         TALLOC_CTX *_mem_save_info_1;
20921         if (flags & NDR_IN) {
20922                 ZERO_STRUCT(r->out);
20923
20924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20925                         NDR_PULL_ALLOC(ndr, r->in.handle);
20926                 }
20927                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20929                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
20932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
20933                 if (_ptr_options) {
20934                         NDR_PULL_ALLOC(ndr, r->in.options);
20935                 } else {
20936                         r->in.options = NULL;
20937                 }
20938                 if (r->in.options) {
20939                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20940                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
20941                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
20943                 }
20944                 NDR_PULL_ALLOC(ndr, r->out.info);
20945                 ZERO_STRUCTP(r->out.info);
20946         }
20947         if (flags & NDR_OUT) {
20948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20949                         NDR_PULL_ALLOC(ndr, r->out.info);
20950                 }
20951                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20952                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
20953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20954                 if (_ptr_info) {
20955                         NDR_PULL_ALLOC(ndr, *r->out.info);
20956                 } else {
20957                         *r->out.info = NULL;
20958                 }
20959                 if (*r->out.info) {
20960                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
20961                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
20962                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
20964                 }
20965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
20966                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20967         }
20968         return NDR_ERR_SUCCESS;
20969 }
20970
20971 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20972 {
20973         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
20974         ndr->depth++;
20975         if (flags & NDR_SET_VALUES) {
20976                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20977         }
20978         if (flags & NDR_IN) {
20979                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
20980                 ndr->depth++;
20981                 ndr_print_ptr(ndr, "handle", r->in.handle);
20982                 ndr->depth++;
20983                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20984                 ndr->depth--;
20985                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
20986                 ndr_print_ptr(ndr, "options", r->in.options);
20987                 ndr->depth++;
20988                 if (r->in.options) {
20989                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
20990                 }
20991                 ndr->depth--;
20992                 ndr->depth--;
20993         }
20994         if (flags & NDR_OUT) {
20995                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
20996                 ndr->depth++;
20997                 ndr_print_ptr(ndr, "info", r->out.info);
20998                 ndr->depth++;
20999                 ndr_print_ptr(ndr, "info", *r->out.info);
21000                 ndr->depth++;
21001                 if (*r->out.info) {
21002                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
21003                 }
21004                 ndr->depth--;
21005                 ndr->depth--;
21006                 ndr_print_WERROR(ndr, "result", r->out.result);
21007                 ndr->depth--;
21008         }
21009         ndr->depth--;
21010 }
21011
21012 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
21013 {
21014         if (flags & NDR_IN) {
21015         }
21016         if (flags & NDR_OUT) {
21017                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21018         }
21019         return NDR_ERR_SUCCESS;
21020 }
21021
21022 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
21023 {
21024         if (flags & NDR_IN) {
21025         }
21026         if (flags & NDR_OUT) {
21027                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21028         }
21029         return NDR_ERR_SUCCESS;
21030 }
21031
21032 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
21033 {
21034         ndr_print_struct(ndr, name, "spoolss_44");
21035         ndr->depth++;
21036         if (flags & NDR_SET_VALUES) {
21037                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21038         }
21039         if (flags & NDR_IN) {
21040                 ndr_print_struct(ndr, "in", "spoolss_44");
21041                 ndr->depth++;
21042                 ndr->depth--;
21043         }
21044         if (flags & NDR_OUT) {
21045                 ndr_print_struct(ndr, "out", "spoolss_44");
21046                 ndr->depth++;
21047                 ndr_print_WERROR(ndr, "result", r->out.result);
21048                 ndr->depth--;
21049         }
21050         ndr->depth--;
21051 }
21052
21053 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
21054 {
21055         if (flags & NDR_IN) {
21056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
21057                 if (r->in.printername) {
21058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21061                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21062                 }
21063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
21064                 if (r->in.datatype) {
21065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21069                 }
21070                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21071                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
21072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21073                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21074                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21075         }
21076         if (flags & NDR_OUT) {
21077                 if (r->out.handle == NULL) {
21078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21079                 }
21080                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21081                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21082         }
21083         return NDR_ERR_SUCCESS;
21084 }
21085
21086 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
21087 {
21088         uint32_t _ptr_printername;
21089         uint32_t _ptr_datatype;
21090         TALLOC_CTX *_mem_save_printername_0;
21091         TALLOC_CTX *_mem_save_datatype_0;
21092         TALLOC_CTX *_mem_save_handle_0;
21093         if (flags & NDR_IN) {
21094                 ZERO_STRUCT(r->out);
21095
21096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
21097                 if (_ptr_printername) {
21098                         NDR_PULL_ALLOC(ndr, r->in.printername);
21099                 } else {
21100                         r->in.printername = NULL;
21101                 }
21102                 if (r->in.printername) {
21103                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21104                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
21105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
21106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
21107                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
21108                                 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));
21109                         }
21110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
21111                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
21112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
21113                 }
21114                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
21115                 if (_ptr_datatype) {
21116                         NDR_PULL_ALLOC(ndr, r->in.datatype);
21117                 } else {
21118                         r->in.datatype = NULL;
21119                 }
21120                 if (r->in.datatype) {
21121                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
21122                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
21123                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
21124                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
21125                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
21126                                 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));
21127                         }
21128                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
21129                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
21130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
21131                 }
21132                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21133                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
21134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21135                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21136                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21137                 NDR_PULL_ALLOC(ndr, r->out.handle);
21138                 ZERO_STRUCTP(r->out.handle);
21139         }
21140         if (flags & NDR_OUT) {
21141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21142                         NDR_PULL_ALLOC(ndr, r->out.handle);
21143                 }
21144                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21145                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21146                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21148                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21149         }
21150         return NDR_ERR_SUCCESS;
21151 }
21152
21153 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
21154 {
21155         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
21156         ndr->depth++;
21157         if (flags & NDR_SET_VALUES) {
21158                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21159         }
21160         if (flags & NDR_IN) {
21161                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
21162                 ndr->depth++;
21163                 ndr_print_ptr(ndr, "printername", r->in.printername);
21164                 ndr->depth++;
21165                 if (r->in.printername) {
21166                         ndr_print_string(ndr, "printername", r->in.printername);
21167                 }
21168                 ndr->depth--;
21169                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
21170                 ndr->depth++;
21171                 if (r->in.datatype) {
21172                         ndr_print_string(ndr, "datatype", r->in.datatype);
21173                 }
21174                 ndr->depth--;
21175                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
21176                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
21177                 ndr_print_uint32(ndr, "level", r->in.level);
21178                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
21179                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
21180                 ndr->depth--;
21181         }
21182         if (flags & NDR_OUT) {
21183                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
21184                 ndr->depth++;
21185                 ndr_print_ptr(ndr, "handle", r->out.handle);
21186                 ndr->depth++;
21187                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21188                 ndr->depth--;
21189                 ndr_print_WERROR(ndr, "result", r->out.result);
21190                 ndr->depth--;
21191         }
21192         ndr->depth--;
21193 }
21194
21195 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
21196 {
21197         if (flags & NDR_IN) {
21198                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21199                 if (r->in.server) {
21200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21202                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21203                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21204                 }
21205                 if (r->in.info_ctr == NULL) {
21206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21207                 }
21208                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21209                 if (r->in.devmode_ctr == NULL) {
21210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21211                 }
21212                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21213                 if (r->in.secdesc_ctr == NULL) {
21214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21215                 }
21216                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21217                 if (r->in.userlevel_ctr == NULL) {
21218                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21219                 }
21220                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21221         }
21222         if (flags & NDR_OUT) {
21223                 if (r->out.handle == NULL) {
21224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21225                 }
21226                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21228         }
21229         return NDR_ERR_SUCCESS;
21230 }
21231
21232 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
21233 {
21234         uint32_t _ptr_server;
21235         TALLOC_CTX *_mem_save_server_0;
21236         TALLOC_CTX *_mem_save_info_ctr_0;
21237         TALLOC_CTX *_mem_save_devmode_ctr_0;
21238         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21239         TALLOC_CTX *_mem_save_userlevel_ctr_0;
21240         TALLOC_CTX *_mem_save_handle_0;
21241         if (flags & NDR_IN) {
21242                 ZERO_STRUCT(r->out);
21243
21244                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21245                 if (_ptr_server) {
21246                         NDR_PULL_ALLOC(ndr, r->in.server);
21247                 } else {
21248                         r->in.server = NULL;
21249                 }
21250                 if (r->in.server) {
21251                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21252                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21255                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21256                                 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));
21257                         }
21258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21261                 }
21262                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21263                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21264                 }
21265                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21266                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21267                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21268                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21270                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21271                 }
21272                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21273                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21274                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21277                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21278                 }
21279                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21280                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21281                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21283                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21284                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
21285                 }
21286                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21287                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
21288                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21289                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21290                 NDR_PULL_ALLOC(ndr, r->out.handle);
21291                 ZERO_STRUCTP(r->out.handle);
21292         }
21293         if (flags & NDR_OUT) {
21294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21295                         NDR_PULL_ALLOC(ndr, r->out.handle);
21296                 }
21297                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21298                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21299                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21301                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21302         }
21303         return NDR_ERR_SUCCESS;
21304 }
21305
21306 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
21307 {
21308         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
21309         ndr->depth++;
21310         if (flags & NDR_SET_VALUES) {
21311                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21312         }
21313         if (flags & NDR_IN) {
21314                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
21315                 ndr->depth++;
21316                 ndr_print_ptr(ndr, "server", r->in.server);
21317                 ndr->depth++;
21318                 if (r->in.server) {
21319                         ndr_print_string(ndr, "server", r->in.server);
21320                 }
21321                 ndr->depth--;
21322                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21323                 ndr->depth++;
21324                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21325                 ndr->depth--;
21326                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21327                 ndr->depth++;
21328                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21329                 ndr->depth--;
21330                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21331                 ndr->depth++;
21332                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21333                 ndr->depth--;
21334                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21335                 ndr->depth++;
21336                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21337                 ndr->depth--;
21338                 ndr->depth--;
21339         }
21340         if (flags & NDR_OUT) {
21341                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
21342                 ndr->depth++;
21343                 ndr_print_ptr(ndr, "handle", r->out.handle);
21344                 ndr->depth++;
21345                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21346                 ndr->depth--;
21347                 ndr_print_WERROR(ndr, "result", r->out.result);
21348                 ndr->depth--;
21349         }
21350         ndr->depth--;
21351 }
21352
21353 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
21354 {
21355         if (flags & NDR_IN) {
21356         }
21357         if (flags & NDR_OUT) {
21358                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21359         }
21360         return NDR_ERR_SUCCESS;
21361 }
21362
21363 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
21364 {
21365         if (flags & NDR_IN) {
21366         }
21367         if (flags & NDR_OUT) {
21368                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21369         }
21370         return NDR_ERR_SUCCESS;
21371 }
21372
21373 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
21374 {
21375         ndr_print_struct(ndr, name, "spoolss_47");
21376         ndr->depth++;
21377         if (flags & NDR_SET_VALUES) {
21378                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21379         }
21380         if (flags & NDR_IN) {
21381                 ndr_print_struct(ndr, "in", "spoolss_47");
21382                 ndr->depth++;
21383                 ndr->depth--;
21384         }
21385         if (flags & NDR_OUT) {
21386                 ndr_print_struct(ndr, "out", "spoolss_47");
21387                 ndr->depth++;
21388                 ndr_print_WERROR(ndr, "result", r->out.result);
21389                 ndr->depth--;
21390         }
21391         ndr->depth--;
21392 }
21393
21394 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
21395 {
21396         if (flags & NDR_IN) {
21397                 if (r->in.handle == NULL) {
21398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21399                 }
21400                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
21402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
21403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
21404         }
21405         if (flags & NDR_OUT) {
21406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
21407                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
21408                 if (r->out.value_needed == NULL) {
21409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21410                 }
21411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
21412                 if (r->out.printerdata_type == NULL) {
21413                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21414                 }
21415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
21416                 if (r->out.buffer == NULL) {
21417                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21418                 }
21419                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
21420                 if (r->out.data_needed == NULL) {
21421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21422                 }
21423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
21424                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21425         }
21426         return NDR_ERR_SUCCESS;
21427 }
21428
21429 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
21430 {
21431         TALLOC_CTX *_mem_save_handle_0;
21432         TALLOC_CTX *_mem_save_value_needed_0;
21433         TALLOC_CTX *_mem_save_printerdata_type_0;
21434         TALLOC_CTX *_mem_save_buffer_0;
21435         TALLOC_CTX *_mem_save_data_needed_0;
21436         if (flags & NDR_IN) {
21437                 ZERO_STRUCT(r->out);
21438
21439                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21440                         NDR_PULL_ALLOC(ndr, r->in.handle);
21441                 }
21442                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21443                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21444                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21445                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
21447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
21448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
21449                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
21450                 ZERO_STRUCTP(r->out.value_needed);
21451                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21452                 ZERO_STRUCTP(r->out.printerdata_type);
21453                 NDR_PULL_ALLOC(ndr, r->out.buffer);
21454                 ZERO_STRUCTP(r->out.buffer);
21455                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
21456                 ZERO_STRUCTP(r->out.data_needed);
21457         }
21458         if (flags & NDR_OUT) {
21459                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
21460                 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));
21461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21462                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
21463                 }
21464                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21465                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
21466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
21467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
21468                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21469                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21470                 }
21471                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21472                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
21473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
21474                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
21475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21476                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21477                 }
21478                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21479                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
21480                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
21481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
21482                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21483                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
21484                 }
21485                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21486                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
21487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
21488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
21489                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21490                 if (r->out.value_name) {
21491                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
21492                 }
21493         }
21494         return NDR_ERR_SUCCESS;
21495 }
21496
21497 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
21498 {
21499         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
21500         ndr->depth++;
21501         if (flags & NDR_SET_VALUES) {
21502                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21503         }
21504         if (flags & NDR_IN) {
21505                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
21506                 ndr->depth++;
21507                 ndr_print_ptr(ndr, "handle", r->in.handle);
21508                 ndr->depth++;
21509                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21510                 ndr->depth--;
21511                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
21512                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
21513                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
21514                 ndr->depth--;
21515         }
21516         if (flags & NDR_OUT) {
21517                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
21518                 ndr->depth++;
21519                 ndr_print_string(ndr, "value_name", r->out.value_name);
21520                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
21521                 ndr->depth++;
21522                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
21523                 ndr->depth--;
21524                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
21525                 ndr->depth++;
21526                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
21527                 ndr->depth--;
21528                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21529                 ndr->depth++;
21530                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
21531                 ndr->depth--;
21532                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
21533                 ndr->depth++;
21534                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
21535                 ndr->depth--;
21536                 ndr_print_WERROR(ndr, "result", r->out.result);
21537                 ndr->depth--;
21538         }
21539         ndr->depth--;
21540 }
21541
21542 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
21543 {
21544         if (flags & NDR_IN) {
21545                 if (r->in.handle == NULL) {
21546                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21547                 }
21548                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21552                 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));
21553         }
21554         if (flags & NDR_OUT) {
21555                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21556         }
21557         return NDR_ERR_SUCCESS;
21558 }
21559
21560 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
21561 {
21562         TALLOC_CTX *_mem_save_handle_0;
21563         if (flags & NDR_IN) {
21564                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21565                         NDR_PULL_ALLOC(ndr, r->in.handle);
21566                 }
21567                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21568                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21569                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21570                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21571                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21572                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21573                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21574                         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));
21575                 }
21576                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21577                 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));
21578         }
21579         if (flags & NDR_OUT) {
21580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21581         }
21582         return NDR_ERR_SUCCESS;
21583 }
21584
21585 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
21586 {
21587         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
21588         ndr->depth++;
21589         if (flags & NDR_SET_VALUES) {
21590                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21591         }
21592         if (flags & NDR_IN) {
21593                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
21594                 ndr->depth++;
21595                 ndr_print_ptr(ndr, "handle", r->in.handle);
21596                 ndr->depth++;
21597                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21598                 ndr->depth--;
21599                 ndr_print_string(ndr, "value_name", r->in.value_name);
21600                 ndr->depth--;
21601         }
21602         if (flags & NDR_OUT) {
21603                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
21604                 ndr->depth++;
21605                 ndr_print_WERROR(ndr, "result", r->out.result);
21606                 ndr->depth--;
21607         }
21608         ndr->depth--;
21609 }
21610
21611 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
21612 {
21613         if (flags & NDR_IN) {
21614         }
21615         if (flags & NDR_OUT) {
21616                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21617         }
21618         return NDR_ERR_SUCCESS;
21619 }
21620
21621 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
21622 {
21623         if (flags & NDR_IN) {
21624         }
21625         if (flags & NDR_OUT) {
21626                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21627         }
21628         return NDR_ERR_SUCCESS;
21629 }
21630
21631 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
21632 {
21633         ndr_print_struct(ndr, name, "spoolss_4a");
21634         ndr->depth++;
21635         if (flags & NDR_SET_VALUES) {
21636                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21637         }
21638         if (flags & NDR_IN) {
21639                 ndr_print_struct(ndr, "in", "spoolss_4a");
21640                 ndr->depth++;
21641                 ndr->depth--;
21642         }
21643         if (flags & NDR_OUT) {
21644                 ndr_print_struct(ndr, "out", "spoolss_4a");
21645                 ndr->depth++;
21646                 ndr_print_WERROR(ndr, "result", r->out.result);
21647                 ndr->depth--;
21648         }
21649         ndr->depth--;
21650 }
21651
21652 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
21653 {
21654         if (flags & NDR_IN) {
21655         }
21656         if (flags & NDR_OUT) {
21657                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21658         }
21659         return NDR_ERR_SUCCESS;
21660 }
21661
21662 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
21663 {
21664         if (flags & NDR_IN) {
21665         }
21666         if (flags & NDR_OUT) {
21667                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21668         }
21669         return NDR_ERR_SUCCESS;
21670 }
21671
21672 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
21673 {
21674         ndr_print_struct(ndr, name, "spoolss_4b");
21675         ndr->depth++;
21676         if (flags & NDR_SET_VALUES) {
21677                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21678         }
21679         if (flags & NDR_IN) {
21680                 ndr_print_struct(ndr, "in", "spoolss_4b");
21681                 ndr->depth++;
21682                 ndr->depth--;
21683         }
21684         if (flags & NDR_OUT) {
21685                 ndr_print_struct(ndr, "out", "spoolss_4b");
21686                 ndr->depth++;
21687                 ndr_print_WERROR(ndr, "result", r->out.result);
21688                 ndr->depth--;
21689         }
21690         ndr->depth--;
21691 }
21692
21693 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
21694 {
21695         if (flags & NDR_IN) {
21696         }
21697         if (flags & NDR_OUT) {
21698                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21699         }
21700         return NDR_ERR_SUCCESS;
21701 }
21702
21703 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
21704 {
21705         if (flags & NDR_IN) {
21706         }
21707         if (flags & NDR_OUT) {
21708                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21709         }
21710         return NDR_ERR_SUCCESS;
21711 }
21712
21713 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
21714 {
21715         ndr_print_struct(ndr, name, "spoolss_4c");
21716         ndr->depth++;
21717         if (flags & NDR_SET_VALUES) {
21718                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21719         }
21720         if (flags & NDR_IN) {
21721                 ndr_print_struct(ndr, "in", "spoolss_4c");
21722                 ndr->depth++;
21723                 ndr->depth--;
21724         }
21725         if (flags & NDR_OUT) {
21726                 ndr_print_struct(ndr, "out", "spoolss_4c");
21727                 ndr->depth++;
21728                 ndr_print_WERROR(ndr, "result", r->out.result);
21729                 ndr->depth--;
21730         }
21731         ndr->depth--;
21732 }
21733
21734 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
21735 {
21736         if (flags & NDR_IN) {
21737                 if (r->in.handle == NULL) {
21738                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21739                 }
21740                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21744                 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));
21745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21748                 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));
21749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
21750                 if (r->in.buffer == NULL) {
21751                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21752                 }
21753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21754                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21756         }
21757         if (flags & NDR_OUT) {
21758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21759         }
21760         return NDR_ERR_SUCCESS;
21761 }
21762
21763 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
21764 {
21765         TALLOC_CTX *_mem_save_handle_0;
21766         if (flags & NDR_IN) {
21767                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21768                         NDR_PULL_ALLOC(ndr, r->in.handle);
21769                 }
21770                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21771                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21772                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21773                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21774                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21775                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21776                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21777                         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));
21778                 }
21779                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21780                 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));
21781                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21782                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21783                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21784                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
21785                 }
21786                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21787                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
21788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
21789                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21791                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21792                 }
21793                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21795                 if (r->in.buffer) {
21796                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21797                 }
21798         }
21799         if (flags & NDR_OUT) {
21800                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21801         }
21802         return NDR_ERR_SUCCESS;
21803 }
21804
21805 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
21806 {
21807         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
21808         ndr->depth++;
21809         if (flags & NDR_SET_VALUES) {
21810                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21811         }
21812         if (flags & NDR_IN) {
21813                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
21814                 ndr->depth++;
21815                 ndr_print_ptr(ndr, "handle", r->in.handle);
21816                 ndr->depth++;
21817                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21818                 ndr->depth--;
21819                 ndr_print_string(ndr, "key_name", r->in.key_name);
21820                 ndr_print_string(ndr, "value_name", r->in.value_name);
21821                 ndr_print_uint32(ndr, "type", r->in.type);
21822                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21823                 ndr->depth++;
21824                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21825                 ndr->depth--;
21826                 ndr_print_uint32(ndr, "offered", r->in.offered);
21827                 ndr->depth--;
21828         }
21829         if (flags & NDR_OUT) {
21830                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
21831                 ndr->depth++;
21832                 ndr_print_WERROR(ndr, "result", r->out.result);
21833                 ndr->depth--;
21834         }
21835         ndr->depth--;
21836 }
21837
21838 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
21839 {
21840         if (flags & NDR_IN) {
21841                 if (r->in.handle == NULL) {
21842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21843                 }
21844                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21848                 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));
21849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21852                 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));
21853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21854         }
21855         if (flags & NDR_OUT) {
21856                 if (r->out.type == NULL) {
21857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21858                 }
21859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
21860                 if (r->out.buffer == NULL) {
21861                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21862                 }
21863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21864                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21865                 if (r->out.needed == NULL) {
21866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21867                 }
21868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21869                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21870         }
21871         return NDR_ERR_SUCCESS;
21872 }
21873
21874 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
21875 {
21876         TALLOC_CTX *_mem_save_handle_0;
21877         TALLOC_CTX *_mem_save_type_0;
21878         TALLOC_CTX *_mem_save_needed_0;
21879         if (flags & NDR_IN) {
21880                 ZERO_STRUCT(r->out);
21881
21882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21883                         NDR_PULL_ALLOC(ndr, r->in.handle);
21884                 }
21885                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21886                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21887                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21889                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21890                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21891                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21892                         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));
21893                 }
21894                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21895                 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));
21896                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21897                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21898                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21899                         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));
21900                 }
21901                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21902                 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));
21903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21904                 NDR_PULL_ALLOC(ndr, r->out.type);
21905                 ZERO_STRUCTP(r->out.type);
21906                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
21907                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
21908                 NDR_PULL_ALLOC(ndr, r->out.needed);
21909                 ZERO_STRUCTP(r->out.needed);
21910         }
21911         if (flags & NDR_OUT) {
21912                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21913                         NDR_PULL_ALLOC(ndr, r->out.type);
21914                 }
21915                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21916                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21917                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
21918                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21919                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21920                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21921                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21922                 }
21923                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21925                         NDR_PULL_ALLOC(ndr, r->out.needed);
21926                 }
21927                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21928                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21931                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21932                 if (r->out.buffer) {
21933                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21934                 }
21935         }
21936         return NDR_ERR_SUCCESS;
21937 }
21938
21939 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
21940 {
21941         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
21942         ndr->depth++;
21943         if (flags & NDR_SET_VALUES) {
21944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21945         }
21946         if (flags & NDR_IN) {
21947                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
21948                 ndr->depth++;
21949                 ndr_print_ptr(ndr, "handle", r->in.handle);
21950                 ndr->depth++;
21951                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21952                 ndr->depth--;
21953                 ndr_print_string(ndr, "key_name", r->in.key_name);
21954                 ndr_print_string(ndr, "value_name", r->in.value_name);
21955                 ndr_print_uint32(ndr, "offered", r->in.offered);
21956                 ndr->depth--;
21957         }
21958         if (flags & NDR_OUT) {
21959                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
21960                 ndr->depth++;
21961                 ndr_print_ptr(ndr, "type", r->out.type);
21962                 ndr->depth++;
21963                 ndr_print_uint32(ndr, "type", *r->out.type);
21964                 ndr->depth--;
21965                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21966                 ndr->depth++;
21967                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21968                 ndr->depth--;
21969                 ndr_print_ptr(ndr, "needed", r->out.needed);
21970                 ndr->depth++;
21971                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21972                 ndr->depth--;
21973                 ndr_print_WERROR(ndr, "result", r->out.result);
21974                 ndr->depth--;
21975         }
21976         ndr->depth--;
21977 }
21978
21979 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
21980 {
21981         if (flags & NDR_IN) {
21982                 if (r->in.handle == NULL) {
21983                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21984                 }
21985                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21989                 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));
21990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21991         }
21992         if (flags & NDR_OUT) {
21993                 if (r->out.buffer == NULL) {
21994                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21995                 }
21996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21997                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21998                 if (r->out.needed == NULL) {
21999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22000                 }
22001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22002                 if (r->out.count == NULL) {
22003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22004                 }
22005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22006                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22007         }
22008         return NDR_ERR_SUCCESS;
22009 }
22010
22011 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
22012 {
22013         TALLOC_CTX *_mem_save_handle_0;
22014         TALLOC_CTX *_mem_save_needed_0;
22015         TALLOC_CTX *_mem_save_count_0;
22016         if (flags & NDR_IN) {
22017                 ZERO_STRUCT(r->out);
22018
22019                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22020                         NDR_PULL_ALLOC(ndr, r->in.handle);
22021                 }
22022                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22023                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22024                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22025                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22026                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22027                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22028                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22029                         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));
22030                 }
22031                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22032                 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));
22033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22034                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
22035                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
22036                 NDR_PULL_ALLOC(ndr, r->out.needed);
22037                 ZERO_STRUCTP(r->out.needed);
22038                 NDR_PULL_ALLOC(ndr, r->out.count);
22039                 ZERO_STRUCTP(r->out.count);
22040         }
22041         if (flags & NDR_OUT) {
22042                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22043                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22044                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22045                 }
22046                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22047                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22048                         NDR_PULL_ALLOC(ndr, r->out.needed);
22049                 }
22050                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22051                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22055                         NDR_PULL_ALLOC(ndr, r->out.count);
22056                 }
22057                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22058                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22062                 if (r->out.buffer) {
22063                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22064                 }
22065         }
22066         return NDR_ERR_SUCCESS;
22067 }
22068
22069 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
22070 {
22071         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
22072         ndr->depth++;
22073         if (flags & NDR_SET_VALUES) {
22074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22075         }
22076         if (flags & NDR_IN) {
22077                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
22078                 ndr->depth++;
22079                 ndr_print_ptr(ndr, "handle", r->in.handle);
22080                 ndr->depth++;
22081                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22082                 ndr->depth--;
22083                 ndr_print_string(ndr, "key_name", r->in.key_name);
22084                 ndr_print_uint32(ndr, "offered", r->in.offered);
22085                 ndr->depth--;
22086         }
22087         if (flags & NDR_OUT) {
22088                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
22089                 ndr->depth++;
22090                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22091                 ndr->depth++;
22092                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22093                 ndr->depth--;
22094                 ndr_print_ptr(ndr, "needed", r->out.needed);
22095                 ndr->depth++;
22096                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22097                 ndr->depth--;
22098                 ndr_print_ptr(ndr, "count", r->out.count);
22099                 ndr->depth++;
22100                 ndr_print_uint32(ndr, "count", *r->out.count);
22101                 ndr->depth--;
22102                 ndr_print_WERROR(ndr, "result", r->out.result);
22103                 ndr->depth--;
22104         }
22105         ndr->depth--;
22106 }
22107
22108 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
22109 {
22110         uint32_t cntr_key_buffer_1;
22111         if (flags & NDR_IN) {
22112                 if (r->in.handle == NULL) {
22113                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22114                 }
22115                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22119                 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));
22120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
22121         }
22122         if (flags & NDR_OUT) {
22123                 if (r->out.key_buffer == NULL) {
22124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22125                 }
22126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
22127                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22128                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
22129                 }
22130                 if (r->out.needed == NULL) {
22131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22132                 }
22133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22134                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22135         }
22136         return NDR_ERR_SUCCESS;
22137 }
22138
22139 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
22140 {
22141         uint32_t cntr_key_buffer_1;
22142         TALLOC_CTX *_mem_save_handle_0;
22143         TALLOC_CTX *_mem_save_key_buffer_1;
22144         TALLOC_CTX *_mem_save_needed_0;
22145         if (flags & NDR_IN) {
22146                 ZERO_STRUCT(r->out);
22147
22148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22149                         NDR_PULL_ALLOC(ndr, r->in.handle);
22150                 }
22151                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22152                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22153                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22155                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22156                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22157                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22158                         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));
22159                 }
22160                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22161                 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));
22162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
22163                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
22164                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
22165                 NDR_PULL_ALLOC(ndr, r->out.needed);
22166                 ZERO_STRUCTP(r->out.needed);
22167         }
22168         if (flags & NDR_OUT) {
22169                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
22170                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22171                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
22172                 }
22173                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
22174                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
22175                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22176                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
22177                 }
22178                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
22179                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22180                         NDR_PULL_ALLOC(ndr, r->out.needed);
22181                 }
22182                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22183                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22186                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22187                 if (r->out.key_buffer) {
22188                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
22189                 }
22190         }
22191         return NDR_ERR_SUCCESS;
22192 }
22193
22194 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
22195 {
22196         uint32_t cntr_key_buffer_1;
22197         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
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_EnumPrinterKey");
22204                 ndr->depth++;
22205                 ndr_print_ptr(ndr, "handle", r->in.handle);
22206                 ndr->depth++;
22207                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22208                 ndr->depth--;
22209                 ndr_print_string(ndr, "key_name", r->in.key_name);
22210                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
22211                 ndr->depth--;
22212         }
22213         if (flags & NDR_OUT) {
22214                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
22215                 ndr->depth++;
22216                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
22217                 ndr->depth++;
22218                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
22219                 ndr->depth++;
22220                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
22221                         char *idx_1=NULL;
22222                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
22223                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
22224                                 free(idx_1);
22225                         }
22226                 }
22227                 ndr->depth--;
22228                 ndr->depth--;
22229                 ndr_print_ptr(ndr, "needed", r->out.needed);
22230                 ndr->depth++;
22231                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22232                 ndr->depth--;
22233                 ndr_print_WERROR(ndr, "result", r->out.result);
22234                 ndr->depth--;
22235         }
22236         ndr->depth--;
22237 }
22238
22239 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
22240 {
22241         if (flags & NDR_IN) {
22242                 if (r->in.handle == NULL) {
22243                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22244                 }
22245                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22249                 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));
22250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22253                 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));
22254         }
22255         if (flags & NDR_OUT) {
22256                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22257         }
22258         return NDR_ERR_SUCCESS;
22259 }
22260
22261 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
22262 {
22263         TALLOC_CTX *_mem_save_handle_0;
22264         if (flags & NDR_IN) {
22265                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22266                         NDR_PULL_ALLOC(ndr, r->in.handle);
22267                 }
22268                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22269                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22270                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22272                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22273                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22274                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22275                         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));
22276                 }
22277                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22278                 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));
22279                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22280                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22281                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22282                         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));
22283                 }
22284                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22285                 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));
22286         }
22287         if (flags & NDR_OUT) {
22288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22289         }
22290         return NDR_ERR_SUCCESS;
22291 }
22292
22293 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
22294 {
22295         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
22296         ndr->depth++;
22297         if (flags & NDR_SET_VALUES) {
22298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22299         }
22300         if (flags & NDR_IN) {
22301                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
22302                 ndr->depth++;
22303                 ndr_print_ptr(ndr, "handle", r->in.handle);
22304                 ndr->depth++;
22305                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22306                 ndr->depth--;
22307                 ndr_print_string(ndr, "key_name", r->in.key_name);
22308                 ndr_print_string(ndr, "value_name", r->in.value_name);
22309                 ndr->depth--;
22310         }
22311         if (flags & NDR_OUT) {
22312                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
22313                 ndr->depth++;
22314                 ndr_print_WERROR(ndr, "result", r->out.result);
22315                 ndr->depth--;
22316         }
22317         ndr->depth--;
22318 }
22319
22320 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
22321 {
22322         if (flags & NDR_IN) {
22323                 if (r->in.handle == NULL) {
22324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22325                 }
22326                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22330                 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));
22331         }
22332         if (flags & NDR_OUT) {
22333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22334         }
22335         return NDR_ERR_SUCCESS;
22336 }
22337
22338 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
22339 {
22340         TALLOC_CTX *_mem_save_handle_0;
22341         if (flags & NDR_IN) {
22342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22343                         NDR_PULL_ALLOC(ndr, r->in.handle);
22344                 }
22345                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22346                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22347                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22349                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22350                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22351                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22352                         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));
22353                 }
22354                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22355                 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));
22356         }
22357         if (flags & NDR_OUT) {
22358                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22359         }
22360         return NDR_ERR_SUCCESS;
22361 }
22362
22363 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
22364 {
22365         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
22366         ndr->depth++;
22367         if (flags & NDR_SET_VALUES) {
22368                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22369         }
22370         if (flags & NDR_IN) {
22371                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
22372                 ndr->depth++;
22373                 ndr_print_ptr(ndr, "handle", r->in.handle);
22374                 ndr->depth++;
22375                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22376                 ndr->depth--;
22377                 ndr_print_string(ndr, "key_name", r->in.key_name);
22378                 ndr->depth--;
22379         }
22380         if (flags & NDR_OUT) {
22381                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
22382                 ndr->depth++;
22383                 ndr_print_WERROR(ndr, "result", r->out.result);
22384                 ndr->depth--;
22385         }
22386         ndr->depth--;
22387 }
22388
22389 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
22390 {
22391         if (flags & NDR_IN) {
22392         }
22393         if (flags & NDR_OUT) {
22394                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22395         }
22396         return NDR_ERR_SUCCESS;
22397 }
22398
22399 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
22400 {
22401         if (flags & NDR_IN) {
22402         }
22403         if (flags & NDR_OUT) {
22404                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22405         }
22406         return NDR_ERR_SUCCESS;
22407 }
22408
22409 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
22410 {
22411         ndr_print_struct(ndr, name, "spoolss_53");
22412         ndr->depth++;
22413         if (flags & NDR_SET_VALUES) {
22414                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22415         }
22416         if (flags & NDR_IN) {
22417                 ndr_print_struct(ndr, "in", "spoolss_53");
22418                 ndr->depth++;
22419                 ndr->depth--;
22420         }
22421         if (flags & NDR_OUT) {
22422                 ndr_print_struct(ndr, "out", "spoolss_53");
22423                 ndr->depth++;
22424                 ndr_print_WERROR(ndr, "result", r->out.result);
22425                 ndr->depth--;
22426         }
22427         ndr->depth--;
22428 }
22429
22430 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22431 {
22432         if (flags & NDR_IN) {
22433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22434                 if (r->in.server) {
22435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22438                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22439                 }
22440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22443                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22447                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22448                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
22449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
22450         }
22451         if (flags & NDR_OUT) {
22452                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22453         }
22454         return NDR_ERR_SUCCESS;
22455 }
22456
22457 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
22458 {
22459         uint32_t _ptr_server;
22460         TALLOC_CTX *_mem_save_server_0;
22461         if (flags & NDR_IN) {
22462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22463                 if (_ptr_server) {
22464                         NDR_PULL_ALLOC(ndr, r->in.server);
22465                 } else {
22466                         r->in.server = NULL;
22467                 }
22468                 if (r->in.server) {
22469                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22470                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22471                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22472                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22473                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22474                                 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));
22475                         }
22476                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22477                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22479                 }
22480                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22481                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22482                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22483                         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));
22484                 }
22485                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22486                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22487                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22488                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22489                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22490                         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));
22491                 }
22492                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22493                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22494                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
22495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
22496         }
22497         if (flags & NDR_OUT) {
22498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22499         }
22500         return NDR_ERR_SUCCESS;
22501 }
22502
22503 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22504 {
22505         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
22506         ndr->depth++;
22507         if (flags & NDR_SET_VALUES) {
22508                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22509         }
22510         if (flags & NDR_IN) {
22511                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
22512                 ndr->depth++;
22513                 ndr_print_ptr(ndr, "server", r->in.server);
22514                 ndr->depth++;
22515                 if (r->in.server) {
22516                         ndr_print_string(ndr, "server", r->in.server);
22517                 }
22518                 ndr->depth--;
22519                 ndr_print_string(ndr, "architecture", r->in.architecture);
22520                 ndr_print_string(ndr, "driver", r->in.driver);
22521                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
22522                 ndr_print_uint32(ndr, "version", r->in.version);
22523                 ndr->depth--;
22524         }
22525         if (flags & NDR_OUT) {
22526                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
22527                 ndr->depth++;
22528                 ndr_print_WERROR(ndr, "result", r->out.result);
22529                 ndr->depth--;
22530         }
22531         ndr->depth--;
22532 }
22533
22534 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
22535 {
22536         if (flags & NDR_IN) {
22537         }
22538         if (flags & NDR_OUT) {
22539                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22540         }
22541         return NDR_ERR_SUCCESS;
22542 }
22543
22544 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
22545 {
22546         if (flags & NDR_IN) {
22547         }
22548         if (flags & NDR_OUT) {
22549                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22550         }
22551         return NDR_ERR_SUCCESS;
22552 }
22553
22554 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
22555 {
22556         ndr_print_struct(ndr, name, "spoolss_55");
22557         ndr->depth++;
22558         if (flags & NDR_SET_VALUES) {
22559                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22560         }
22561         if (flags & NDR_IN) {
22562                 ndr_print_struct(ndr, "in", "spoolss_55");
22563                 ndr->depth++;
22564                 ndr->depth--;
22565         }
22566         if (flags & NDR_OUT) {
22567                 ndr_print_struct(ndr, "out", "spoolss_55");
22568                 ndr->depth++;
22569                 ndr_print_WERROR(ndr, "result", r->out.result);
22570                 ndr->depth--;
22571         }
22572         ndr->depth--;
22573 }
22574
22575 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
22576 {
22577         if (flags & NDR_IN) {
22578         }
22579         if (flags & NDR_OUT) {
22580                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22581         }
22582         return NDR_ERR_SUCCESS;
22583 }
22584
22585 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
22586 {
22587         if (flags & NDR_IN) {
22588         }
22589         if (flags & NDR_OUT) {
22590                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22591         }
22592         return NDR_ERR_SUCCESS;
22593 }
22594
22595 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
22596 {
22597         ndr_print_struct(ndr, name, "spoolss_56");
22598         ndr->depth++;
22599         if (flags & NDR_SET_VALUES) {
22600                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22601         }
22602         if (flags & NDR_IN) {
22603                 ndr_print_struct(ndr, "in", "spoolss_56");
22604                 ndr->depth++;
22605                 ndr->depth--;
22606         }
22607         if (flags & NDR_OUT) {
22608                 ndr_print_struct(ndr, "out", "spoolss_56");
22609                 ndr->depth++;
22610                 ndr_print_WERROR(ndr, "result", r->out.result);
22611                 ndr->depth--;
22612         }
22613         ndr->depth--;
22614 }
22615
22616 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
22617 {
22618         if (flags & NDR_IN) {
22619         }
22620         if (flags & NDR_OUT) {
22621                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22622         }
22623         return NDR_ERR_SUCCESS;
22624 }
22625
22626 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
22627 {
22628         if (flags & NDR_IN) {
22629         }
22630         if (flags & NDR_OUT) {
22631                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22632         }
22633         return NDR_ERR_SUCCESS;
22634 }
22635
22636 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
22637 {
22638         ndr_print_struct(ndr, name, "spoolss_57");
22639         ndr->depth++;
22640         if (flags & NDR_SET_VALUES) {
22641                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22642         }
22643         if (flags & NDR_IN) {
22644                 ndr_print_struct(ndr, "in", "spoolss_57");
22645                 ndr->depth++;
22646                 ndr->depth--;
22647         }
22648         if (flags & NDR_OUT) {
22649                 ndr_print_struct(ndr, "out", "spoolss_57");
22650                 ndr->depth++;
22651                 ndr_print_WERROR(ndr, "result", r->out.result);
22652                 ndr->depth--;
22653         }
22654         ndr->depth--;
22655 }
22656
22657 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
22658 {
22659         if (flags & NDR_IN) {
22660                 if (r->in.handle == NULL) {
22661                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22662                 }
22663                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22667                 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));
22668                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
22669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
22670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22671                 if (r->in.status_code == NULL) {
22672                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22673                 }
22674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
22675         }
22676         if (flags & NDR_OUT) {
22677                 if (r->out.out_data == NULL) {
22678                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22679                 }
22680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22681                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
22682                 if (r->out.needed == NULL) {
22683                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22684                 }
22685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22686                 if (r->out.status_code == NULL) {
22687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22688                 }
22689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
22690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22691         }
22692         return NDR_ERR_SUCCESS;
22693 }
22694
22695 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
22696 {
22697         TALLOC_CTX *_mem_save_handle_0;
22698         TALLOC_CTX *_mem_save_needed_0;
22699         TALLOC_CTX *_mem_save_status_code_0;
22700         if (flags & NDR_IN) {
22701                 ZERO_STRUCT(r->out);
22702
22703                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22704                         NDR_PULL_ALLOC(ndr, r->in.handle);
22705                 }
22706                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22707                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22708                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22709                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22710                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
22711                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
22712                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
22713                         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));
22714                 }
22715                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
22716                 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));
22717                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
22718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
22719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
22720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22721                         NDR_PULL_ALLOC(ndr, r->in.status_code);
22722                 }
22723                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22724                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
22725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
22726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22727                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
22728                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
22729                 NDR_PULL_ALLOC(ndr, r->out.needed);
22730                 ZERO_STRUCTP(r->out.needed);
22731                 NDR_PULL_ALLOC(ndr, r->out.status_code);
22732                 *r->out.status_code = *r->in.status_code;
22733         }
22734         if (flags & NDR_OUT) {
22735                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
22736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22737                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
22738                 }
22739                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
22740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22741                         NDR_PULL_ALLOC(ndr, r->out.needed);
22742                 }
22743                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22744                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22748                         NDR_PULL_ALLOC(ndr, r->out.status_code);
22749                 }
22750                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22751                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
22752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
22753                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22754                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22755                 if (r->out.out_data) {
22756                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
22757                 }
22758         }
22759         return NDR_ERR_SUCCESS;
22760 }
22761
22762 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
22763 {
22764         ndr_print_struct(ndr, name, "spoolss_XcvData");
22765         ndr->depth++;
22766         if (flags & NDR_SET_VALUES) {
22767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22768         }
22769         if (flags & NDR_IN) {
22770                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
22771                 ndr->depth++;
22772                 ndr_print_ptr(ndr, "handle", r->in.handle);
22773                 ndr->depth++;
22774                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22775                 ndr->depth--;
22776                 ndr_print_string(ndr, "function_name", r->in.function_name);
22777                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
22778                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
22779                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
22780                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
22781                 ndr->depth++;
22782                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
22783                 ndr->depth--;
22784                 ndr->depth--;
22785         }
22786         if (flags & NDR_OUT) {
22787                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
22788                 ndr->depth++;
22789                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
22790                 ndr->depth++;
22791                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
22792                 ndr->depth--;
22793                 ndr_print_ptr(ndr, "needed", r->out.needed);
22794                 ndr->depth++;
22795                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22796                 ndr->depth--;
22797                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
22798                 ndr->depth++;
22799                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
22800                 ndr->depth--;
22801                 ndr_print_WERROR(ndr, "result", r->out.result);
22802                 ndr->depth--;
22803         }
22804         ndr->depth--;
22805 }
22806
22807 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
22808 {
22809         if (flags & NDR_IN) {
22810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22811                 if (r->in.servername) {
22812                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22814                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22816                 }
22817                 if (r->in.info_ctr == NULL) {
22818                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22819                 }
22820                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22821                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
22822         }
22823         if (flags & NDR_OUT) {
22824                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22825         }
22826         return NDR_ERR_SUCCESS;
22827 }
22828
22829 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
22830 {
22831         uint32_t _ptr_servername;
22832         TALLOC_CTX *_mem_save_servername_0;
22833         TALLOC_CTX *_mem_save_info_ctr_0;
22834         if (flags & NDR_IN) {
22835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22836                 if (_ptr_servername) {
22837                         NDR_PULL_ALLOC(ndr, r->in.servername);
22838                 } else {
22839                         r->in.servername = NULL;
22840                 }
22841                 if (r->in.servername) {
22842                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22843                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22844                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22845                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22846                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22847                                 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));
22848                         }
22849                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22850                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22852                 }
22853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22854                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
22855                 }
22856                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
22857                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
22858                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
22860                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
22861         }
22862         if (flags & NDR_OUT) {
22863                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22864         }
22865         return NDR_ERR_SUCCESS;
22866 }
22867
22868 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
22869 {
22870         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
22871         ndr->depth++;
22872         if (flags & NDR_SET_VALUES) {
22873                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22874         }
22875         if (flags & NDR_IN) {
22876                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
22877                 ndr->depth++;
22878                 ndr_print_ptr(ndr, "servername", r->in.servername);
22879                 ndr->depth++;
22880                 if (r->in.servername) {
22881                         ndr_print_string(ndr, "servername", r->in.servername);
22882                 }
22883                 ndr->depth--;
22884                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
22885                 ndr->depth++;
22886                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
22887                 ndr->depth--;
22888                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
22889                 ndr->depth--;
22890         }
22891         if (flags & NDR_OUT) {
22892                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
22893                 ndr->depth++;
22894                 ndr_print_WERROR(ndr, "result", r->out.result);
22895                 ndr->depth--;
22896         }
22897         ndr->depth--;
22898 }
22899
22900 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
22901 {
22902         if (flags & NDR_IN) {
22903         }
22904         if (flags & NDR_OUT) {
22905                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22906         }
22907         return NDR_ERR_SUCCESS;
22908 }
22909
22910 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
22911 {
22912         if (flags & NDR_IN) {
22913         }
22914         if (flags & NDR_OUT) {
22915                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22916         }
22917         return NDR_ERR_SUCCESS;
22918 }
22919
22920 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
22921 {
22922         ndr_print_struct(ndr, name, "spoolss_5a");
22923         ndr->depth++;
22924         if (flags & NDR_SET_VALUES) {
22925                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22926         }
22927         if (flags & NDR_IN) {
22928                 ndr_print_struct(ndr, "in", "spoolss_5a");
22929                 ndr->depth++;
22930                 ndr->depth--;
22931         }
22932         if (flags & NDR_OUT) {
22933                 ndr_print_struct(ndr, "out", "spoolss_5a");
22934                 ndr->depth++;
22935                 ndr_print_WERROR(ndr, "result", r->out.result);
22936                 ndr->depth--;
22937         }
22938         ndr->depth--;
22939 }
22940
22941 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
22942 {
22943         if (flags & NDR_IN) {
22944         }
22945         if (flags & NDR_OUT) {
22946                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22947         }
22948         return NDR_ERR_SUCCESS;
22949 }
22950
22951 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
22952 {
22953         if (flags & NDR_IN) {
22954         }
22955         if (flags & NDR_OUT) {
22956                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22957         }
22958         return NDR_ERR_SUCCESS;
22959 }
22960
22961 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
22962 {
22963         ndr_print_struct(ndr, name, "spoolss_5b");
22964         ndr->depth++;
22965         if (flags & NDR_SET_VALUES) {
22966                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22967         }
22968         if (flags & NDR_IN) {
22969                 ndr_print_struct(ndr, "in", "spoolss_5b");
22970                 ndr->depth++;
22971                 ndr->depth--;
22972         }
22973         if (flags & NDR_OUT) {
22974                 ndr_print_struct(ndr, "out", "spoolss_5b");
22975                 ndr->depth++;
22976                 ndr_print_WERROR(ndr, "result", r->out.result);
22977                 ndr->depth--;
22978         }
22979         ndr->depth--;
22980 }
22981
22982 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
22983 {
22984         if (flags & NDR_IN) {
22985         }
22986         if (flags & NDR_OUT) {
22987                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22988         }
22989         return NDR_ERR_SUCCESS;
22990 }
22991
22992 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
22993 {
22994         if (flags & NDR_IN) {
22995         }
22996         if (flags & NDR_OUT) {
22997                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22998         }
22999         return NDR_ERR_SUCCESS;
23000 }
23001
23002 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
23003 {
23004         ndr_print_struct(ndr, name, "spoolss_5c");
23005         ndr->depth++;
23006         if (flags & NDR_SET_VALUES) {
23007                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23008         }
23009         if (flags & NDR_IN) {
23010                 ndr_print_struct(ndr, "in", "spoolss_5c");
23011                 ndr->depth++;
23012                 ndr->depth--;
23013         }
23014         if (flags & NDR_OUT) {
23015                 ndr_print_struct(ndr, "out", "spoolss_5c");
23016                 ndr->depth++;
23017                 ndr_print_WERROR(ndr, "result", r->out.result);
23018                 ndr->depth--;
23019         }
23020         ndr->depth--;
23021 }
23022
23023 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
23024 {
23025         if (flags & NDR_IN) {
23026         }
23027         if (flags & NDR_OUT) {
23028                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23029         }
23030         return NDR_ERR_SUCCESS;
23031 }
23032
23033 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
23034 {
23035         if (flags & NDR_IN) {
23036         }
23037         if (flags & NDR_OUT) {
23038                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23039         }
23040         return NDR_ERR_SUCCESS;
23041 }
23042
23043 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
23044 {
23045         ndr_print_struct(ndr, name, "spoolss_5d");
23046         ndr->depth++;
23047         if (flags & NDR_SET_VALUES) {
23048                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23049         }
23050         if (flags & NDR_IN) {
23051                 ndr_print_struct(ndr, "in", "spoolss_5d");
23052                 ndr->depth++;
23053                 ndr->depth--;
23054         }
23055         if (flags & NDR_OUT) {
23056                 ndr_print_struct(ndr, "out", "spoolss_5d");
23057                 ndr->depth++;
23058                 ndr_print_WERROR(ndr, "result", r->out.result);
23059                 ndr->depth--;
23060         }
23061         ndr->depth--;
23062 }
23063
23064 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
23065 {
23066         if (flags & NDR_IN) {
23067         }
23068         if (flags & NDR_OUT) {
23069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23070         }
23071         return NDR_ERR_SUCCESS;
23072 }
23073
23074 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
23075 {
23076         if (flags & NDR_IN) {
23077         }
23078         if (flags & NDR_OUT) {
23079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23080         }
23081         return NDR_ERR_SUCCESS;
23082 }
23083
23084 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
23085 {
23086         ndr_print_struct(ndr, name, "spoolss_5e");
23087         ndr->depth++;
23088         if (flags & NDR_SET_VALUES) {
23089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23090         }
23091         if (flags & NDR_IN) {
23092                 ndr_print_struct(ndr, "in", "spoolss_5e");
23093                 ndr->depth++;
23094                 ndr->depth--;
23095         }
23096         if (flags & NDR_OUT) {
23097                 ndr_print_struct(ndr, "out", "spoolss_5e");
23098                 ndr->depth++;
23099                 ndr_print_WERROR(ndr, "result", r->out.result);
23100                 ndr->depth--;
23101         }
23102         ndr->depth--;
23103 }
23104
23105 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
23106 {
23107         if (flags & NDR_IN) {
23108         }
23109         if (flags & NDR_OUT) {
23110                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23111         }
23112         return NDR_ERR_SUCCESS;
23113 }
23114
23115 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
23116 {
23117         if (flags & NDR_IN) {
23118         }
23119         if (flags & NDR_OUT) {
23120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23121         }
23122         return NDR_ERR_SUCCESS;
23123 }
23124
23125 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
23126 {
23127         ndr_print_struct(ndr, name, "spoolss_5f");
23128         ndr->depth++;
23129         if (flags & NDR_SET_VALUES) {
23130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23131         }
23132         if (flags & NDR_IN) {
23133                 ndr_print_struct(ndr, "in", "spoolss_5f");
23134                 ndr->depth++;
23135                 ndr->depth--;
23136         }
23137         if (flags & NDR_OUT) {
23138                 ndr_print_struct(ndr, "out", "spoolss_5f");
23139                 ndr->depth++;
23140                 ndr_print_WERROR(ndr, "result", r->out.result);
23141                 ndr->depth--;
23142         }
23143         ndr->depth--;
23144 }
23145
23146 static const struct ndr_interface_call spoolss_calls[] = {
23147         {
23148                 "spoolss_EnumPrinters",
23149                 sizeof(struct spoolss_EnumPrinters),
23150                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
23151                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
23152                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
23153                 false,
23154         },
23155         {
23156                 "spoolss_OpenPrinter",
23157                 sizeof(struct spoolss_OpenPrinter),
23158                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
23159                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
23160                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
23161                 false,
23162         },
23163         {
23164                 "spoolss_SetJob",
23165                 sizeof(struct spoolss_SetJob),
23166                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
23167                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
23168                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
23169                 false,
23170         },
23171         {
23172                 "spoolss_GetJob",
23173                 sizeof(struct spoolss_GetJob),
23174                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
23175                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
23176                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
23177                 false,
23178         },
23179         {
23180                 "spoolss_EnumJobs",
23181                 sizeof(struct spoolss_EnumJobs),
23182                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
23183                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
23184                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
23185                 false,
23186         },
23187         {
23188                 "spoolss_AddPrinter",
23189                 sizeof(struct spoolss_AddPrinter),
23190                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
23191                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
23192                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
23193                 false,
23194         },
23195         {
23196                 "spoolss_DeletePrinter",
23197                 sizeof(struct spoolss_DeletePrinter),
23198                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
23199                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
23200                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
23201                 false,
23202         },
23203         {
23204                 "spoolss_SetPrinter",
23205                 sizeof(struct spoolss_SetPrinter),
23206                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
23207                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
23208                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
23209                 false,
23210         },
23211         {
23212                 "spoolss_GetPrinter",
23213                 sizeof(struct spoolss_GetPrinter),
23214                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
23215                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
23216                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
23217                 false,
23218         },
23219         {
23220                 "spoolss_AddPrinterDriver",
23221                 sizeof(struct spoolss_AddPrinterDriver),
23222                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
23223                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
23224                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
23225                 false,
23226         },
23227         {
23228                 "spoolss_EnumPrinterDrivers",
23229                 sizeof(struct spoolss_EnumPrinterDrivers),
23230                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
23231                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
23232                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
23233                 false,
23234         },
23235         {
23236                 "spoolss_GetPrinterDriver",
23237                 sizeof(struct spoolss_GetPrinterDriver),
23238                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
23239                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
23240                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
23241                 false,
23242         },
23243         {
23244                 "spoolss_GetPrinterDriverDirectory",
23245                 sizeof(struct spoolss_GetPrinterDriverDirectory),
23246                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
23247                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
23248                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
23249                 false,
23250         },
23251         {
23252                 "spoolss_DeletePrinterDriver",
23253                 sizeof(struct spoolss_DeletePrinterDriver),
23254                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
23255                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
23256                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
23257                 false,
23258         },
23259         {
23260                 "spoolss_AddPrintProcessor",
23261                 sizeof(struct spoolss_AddPrintProcessor),
23262                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
23263                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
23264                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
23265                 false,
23266         },
23267         {
23268                 "spoolss_EnumPrintProcessors",
23269                 sizeof(struct spoolss_EnumPrintProcessors),
23270                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
23271                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
23272                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
23273                 false,
23274         },
23275         {
23276                 "spoolss_GetPrintProcessorDirectory",
23277                 sizeof(struct spoolss_GetPrintProcessorDirectory),
23278                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
23279                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
23280                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
23281                 false,
23282         },
23283         {
23284                 "spoolss_StartDocPrinter",
23285                 sizeof(struct spoolss_StartDocPrinter),
23286                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
23287                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
23288                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
23289                 false,
23290         },
23291         {
23292                 "spoolss_StartPagePrinter",
23293                 sizeof(struct spoolss_StartPagePrinter),
23294                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
23295                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
23296                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
23297                 false,
23298         },
23299         {
23300                 "spoolss_WritePrinter",
23301                 sizeof(struct spoolss_WritePrinter),
23302                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
23303                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
23304                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
23305                 false,
23306         },
23307         {
23308                 "spoolss_EndPagePrinter",
23309                 sizeof(struct spoolss_EndPagePrinter),
23310                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
23311                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
23312                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
23313                 false,
23314         },
23315         {
23316                 "spoolss_AbortPrinter",
23317                 sizeof(struct spoolss_AbortPrinter),
23318                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
23319                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
23320                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
23321                 false,
23322         },
23323         {
23324                 "spoolss_ReadPrinter",
23325                 sizeof(struct spoolss_ReadPrinter),
23326                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
23327                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
23328                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
23329                 false,
23330         },
23331         {
23332                 "spoolss_EndDocPrinter",
23333                 sizeof(struct spoolss_EndDocPrinter),
23334                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
23335                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
23336                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
23337                 false,
23338         },
23339         {
23340                 "spoolss_AddJob",
23341                 sizeof(struct spoolss_AddJob),
23342                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
23343                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
23344                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
23345                 false,
23346         },
23347         {
23348                 "spoolss_ScheduleJob",
23349                 sizeof(struct spoolss_ScheduleJob),
23350                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
23351                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
23352                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
23353                 false,
23354         },
23355         {
23356                 "spoolss_GetPrinterData",
23357                 sizeof(struct spoolss_GetPrinterData),
23358                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
23359                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
23360                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
23361                 false,
23362         },
23363         {
23364                 "spoolss_SetPrinterData",
23365                 sizeof(struct spoolss_SetPrinterData),
23366                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
23367                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
23368                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
23369                 false,
23370         },
23371         {
23372                 "spoolss_WaitForPrinterChange",
23373                 sizeof(struct spoolss_WaitForPrinterChange),
23374                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
23375                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
23376                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
23377                 false,
23378         },
23379         {
23380                 "spoolss_ClosePrinter",
23381                 sizeof(struct spoolss_ClosePrinter),
23382                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
23383                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
23384                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
23385                 false,
23386         },
23387         {
23388                 "spoolss_AddForm",
23389                 sizeof(struct spoolss_AddForm),
23390                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
23391                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
23392                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
23393                 false,
23394         },
23395         {
23396                 "spoolss_DeleteForm",
23397                 sizeof(struct spoolss_DeleteForm),
23398                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
23399                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
23400                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
23401                 false,
23402         },
23403         {
23404                 "spoolss_GetForm",
23405                 sizeof(struct spoolss_GetForm),
23406                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
23407                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
23408                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
23409                 false,
23410         },
23411         {
23412                 "spoolss_SetForm",
23413                 sizeof(struct spoolss_SetForm),
23414                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
23415                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
23416                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
23417                 false,
23418         },
23419         {
23420                 "spoolss_EnumForms",
23421                 sizeof(struct spoolss_EnumForms),
23422                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
23423                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
23424                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
23425                 false,
23426         },
23427         {
23428                 "spoolss_EnumPorts",
23429                 sizeof(struct spoolss_EnumPorts),
23430                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
23431                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
23432                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
23433                 false,
23434         },
23435         {
23436                 "spoolss_EnumMonitors",
23437                 sizeof(struct spoolss_EnumMonitors),
23438                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
23439                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
23440                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
23441                 false,
23442         },
23443         {
23444                 "spoolss_AddPort",
23445                 sizeof(struct spoolss_AddPort),
23446                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
23447                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
23448                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
23449                 false,
23450         },
23451         {
23452                 "spoolss_ConfigurePort",
23453                 sizeof(struct spoolss_ConfigurePort),
23454                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
23455                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
23456                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
23457                 false,
23458         },
23459         {
23460                 "spoolss_DeletePort",
23461                 sizeof(struct spoolss_DeletePort),
23462                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
23463                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
23464                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
23465                 false,
23466         },
23467         {
23468                 "spoolss_CreatePrinterIC",
23469                 sizeof(struct spoolss_CreatePrinterIC),
23470                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
23471                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
23472                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
23473                 false,
23474         },
23475         {
23476                 "spoolss_PlayGDIScriptOnPrinterIC",
23477                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
23478                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
23479                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
23480                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
23481                 false,
23482         },
23483         {
23484                 "spoolss_DeletePrinterIC",
23485                 sizeof(struct spoolss_DeletePrinterIC),
23486                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
23487                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
23488                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
23489                 false,
23490         },
23491         {
23492                 "spoolss_AddPrinterConnection",
23493                 sizeof(struct spoolss_AddPrinterConnection),
23494                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
23495                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
23496                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
23497                 false,
23498         },
23499         {
23500                 "spoolss_DeletePrinterConnection",
23501                 sizeof(struct spoolss_DeletePrinterConnection),
23502                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
23503                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
23504                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
23505                 false,
23506         },
23507         {
23508                 "spoolss_PrinterMessageBox",
23509                 sizeof(struct spoolss_PrinterMessageBox),
23510                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
23511                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
23512                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
23513                 false,
23514         },
23515         {
23516                 "spoolss_AddMonitor",
23517                 sizeof(struct spoolss_AddMonitor),
23518                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
23519                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
23520                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
23521                 false,
23522         },
23523         {
23524                 "spoolss_DeleteMonitor",
23525                 sizeof(struct spoolss_DeleteMonitor),
23526                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
23527                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
23528                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
23529                 false,
23530         },
23531         {
23532                 "spoolss_DeletePrintProcessor",
23533                 sizeof(struct spoolss_DeletePrintProcessor),
23534                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
23535                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
23536                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
23537                 false,
23538         },
23539         {
23540                 "spoolss_AddPrintProvidor",
23541                 sizeof(struct spoolss_AddPrintProvidor),
23542                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
23543                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
23544                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
23545                 false,
23546         },
23547         {
23548                 "spoolss_DeletePrintProvidor",
23549                 sizeof(struct spoolss_DeletePrintProvidor),
23550                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
23551                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
23552                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
23553                 false,
23554         },
23555         {
23556                 "spoolss_EnumPrintProcDataTypes",
23557                 sizeof(struct spoolss_EnumPrintProcDataTypes),
23558                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
23559                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
23560                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
23561                 false,
23562         },
23563         {
23564                 "spoolss_ResetPrinter",
23565                 sizeof(struct spoolss_ResetPrinter),
23566                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
23567                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
23568                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
23569                 false,
23570         },
23571         {
23572                 "spoolss_GetPrinterDriver2",
23573                 sizeof(struct spoolss_GetPrinterDriver2),
23574                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
23575                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
23576                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
23577                 false,
23578         },
23579         {
23580                 "spoolss_FindFirstPrinterChangeNotification",
23581                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
23582                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
23583                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
23584                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
23585                 false,
23586         },
23587         {
23588                 "spoolss_FindNextPrinterChangeNotification",
23589                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
23590                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
23591                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
23592                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
23593                 false,
23594         },
23595         {
23596                 "spoolss_FindClosePrinterNotify",
23597                 sizeof(struct spoolss_FindClosePrinterNotify),
23598                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
23599                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
23600                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
23601                 false,
23602         },
23603         {
23604                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
23605                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
23606                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23607                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23608                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23609                 false,
23610         },
23611         {
23612                 "spoolss_ReplyOpenPrinter",
23613                 sizeof(struct spoolss_ReplyOpenPrinter),
23614                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
23615                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
23616                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
23617                 false,
23618         },
23619         {
23620                 "spoolss_RouterReplyPrinter",
23621                 sizeof(struct spoolss_RouterReplyPrinter),
23622                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
23623                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
23624                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
23625                 false,
23626         },
23627         {
23628                 "spoolss_ReplyClosePrinter",
23629                 sizeof(struct spoolss_ReplyClosePrinter),
23630                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
23631                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
23632                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
23633                 false,
23634         },
23635         {
23636                 "spoolss_AddPortEx",
23637                 sizeof(struct spoolss_AddPortEx),
23638                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
23639                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
23640                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
23641                 false,
23642         },
23643         {
23644                 "spoolss_RouterFindFirstPrinterChangeNotification",
23645                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
23646                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
23647                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
23648                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
23649                 false,
23650         },
23651         {
23652                 "spoolss_SpoolerInit",
23653                 sizeof(struct spoolss_SpoolerInit),
23654                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
23655                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
23656                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
23657                 false,
23658         },
23659         {
23660                 "spoolss_ResetPrinterEx",
23661                 sizeof(struct spoolss_ResetPrinterEx),
23662                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
23663                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
23664                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
23665                 false,
23666         },
23667         {
23668                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
23669                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
23670                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23671                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23672                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23673                 false,
23674         },
23675         {
23676                 "spoolss_RouterReplyPrinterEx",
23677                 sizeof(struct spoolss_RouterReplyPrinterEx),
23678                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
23679                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
23680                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
23681                 false,
23682         },
23683         {
23684                 "spoolss_RouterRefreshPrinterChangeNotify",
23685                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
23686                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
23687                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
23688                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
23689                 false,
23690         },
23691         {
23692                 "spoolss_44",
23693                 sizeof(struct spoolss_44),
23694                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
23695                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
23696                 (ndr_print_function_t) ndr_print_spoolss_44,
23697                 false,
23698         },
23699         {
23700                 "spoolss_OpenPrinterEx",
23701                 sizeof(struct spoolss_OpenPrinterEx),
23702                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
23703                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
23704                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
23705                 false,
23706         },
23707         {
23708                 "spoolss_AddPrinterEx",
23709                 sizeof(struct spoolss_AddPrinterEx),
23710                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
23711                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
23712                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
23713                 false,
23714         },
23715         {
23716                 "spoolss_47",
23717                 sizeof(struct spoolss_47),
23718                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
23719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
23720                 (ndr_print_function_t) ndr_print_spoolss_47,
23721                 false,
23722         },
23723         {
23724                 "spoolss_EnumPrinterData",
23725                 sizeof(struct spoolss_EnumPrinterData),
23726                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
23727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
23728                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
23729                 false,
23730         },
23731         {
23732                 "spoolss_DeletePrinterData",
23733                 sizeof(struct spoolss_DeletePrinterData),
23734                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
23735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
23736                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
23737                 false,
23738         },
23739         {
23740                 "spoolss_4a",
23741                 sizeof(struct spoolss_4a),
23742                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
23743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
23744                 (ndr_print_function_t) ndr_print_spoolss_4a,
23745                 false,
23746         },
23747         {
23748                 "spoolss_4b",
23749                 sizeof(struct spoolss_4b),
23750                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
23751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
23752                 (ndr_print_function_t) ndr_print_spoolss_4b,
23753                 false,
23754         },
23755         {
23756                 "spoolss_4c",
23757                 sizeof(struct spoolss_4c),
23758                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
23759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
23760                 (ndr_print_function_t) ndr_print_spoolss_4c,
23761                 false,
23762         },
23763         {
23764                 "spoolss_SetPrinterDataEx",
23765                 sizeof(struct spoolss_SetPrinterDataEx),
23766                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
23767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
23768                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
23769                 false,
23770         },
23771         {
23772                 "spoolss_GetPrinterDataEx",
23773                 sizeof(struct spoolss_GetPrinterDataEx),
23774                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
23775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
23776                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
23777                 false,
23778         },
23779         {
23780                 "spoolss_EnumPrinterDataEx",
23781                 sizeof(struct spoolss_EnumPrinterDataEx),
23782                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
23783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
23784                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
23785                 false,
23786         },
23787         {
23788                 "spoolss_EnumPrinterKey",
23789                 sizeof(struct spoolss_EnumPrinterKey),
23790                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
23791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
23792                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
23793                 false,
23794         },
23795         {
23796                 "spoolss_DeletePrinterDataEx",
23797                 sizeof(struct spoolss_DeletePrinterDataEx),
23798                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
23799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
23800                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
23801                 false,
23802         },
23803         {
23804                 "spoolss_DeletePrinterKey",
23805                 sizeof(struct spoolss_DeletePrinterKey),
23806                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
23807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
23808                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
23809                 false,
23810         },
23811         {
23812                 "spoolss_53",
23813                 sizeof(struct spoolss_53),
23814                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
23815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
23816                 (ndr_print_function_t) ndr_print_spoolss_53,
23817                 false,
23818         },
23819         {
23820                 "spoolss_DeletePrinterDriverEx",
23821                 sizeof(struct spoolss_DeletePrinterDriverEx),
23822                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
23823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
23824                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
23825                 false,
23826         },
23827         {
23828                 "spoolss_55",
23829                 sizeof(struct spoolss_55),
23830                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
23831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
23832                 (ndr_print_function_t) ndr_print_spoolss_55,
23833                 false,
23834         },
23835         {
23836                 "spoolss_56",
23837                 sizeof(struct spoolss_56),
23838                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
23839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
23840                 (ndr_print_function_t) ndr_print_spoolss_56,
23841                 false,
23842         },
23843         {
23844                 "spoolss_57",
23845                 sizeof(struct spoolss_57),
23846                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
23847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
23848                 (ndr_print_function_t) ndr_print_spoolss_57,
23849                 false,
23850         },
23851         {
23852                 "spoolss_XcvData",
23853                 sizeof(struct spoolss_XcvData),
23854                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
23855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
23856                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
23857                 false,
23858         },
23859         {
23860                 "spoolss_AddPrinterDriverEx",
23861                 sizeof(struct spoolss_AddPrinterDriverEx),
23862                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
23863                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
23864                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
23865                 false,
23866         },
23867         {
23868                 "spoolss_5a",
23869                 sizeof(struct spoolss_5a),
23870                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
23871                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
23872                 (ndr_print_function_t) ndr_print_spoolss_5a,
23873                 false,
23874         },
23875         {
23876                 "spoolss_5b",
23877                 sizeof(struct spoolss_5b),
23878                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
23879                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
23880                 (ndr_print_function_t) ndr_print_spoolss_5b,
23881                 false,
23882         },
23883         {
23884                 "spoolss_5c",
23885                 sizeof(struct spoolss_5c),
23886                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
23887                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
23888                 (ndr_print_function_t) ndr_print_spoolss_5c,
23889                 false,
23890         },
23891         {
23892                 "spoolss_5d",
23893                 sizeof(struct spoolss_5d),
23894                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
23895                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
23896                 (ndr_print_function_t) ndr_print_spoolss_5d,
23897                 false,
23898         },
23899         {
23900                 "spoolss_5e",
23901                 sizeof(struct spoolss_5e),
23902                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
23903                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
23904                 (ndr_print_function_t) ndr_print_spoolss_5e,
23905                 false,
23906         },
23907         {
23908                 "spoolss_5f",
23909                 sizeof(struct spoolss_5f),
23910                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
23911                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
23912                 (ndr_print_function_t) ndr_print_spoolss_5f,
23913                 false,
23914         },
23915         { NULL, 0, NULL, NULL, NULL, false }
23916 };
23917
23918 static const char * const spoolss_endpoint_strings[] = {
23919         "ncacn_np:[\\pipe\\spoolss]",
23920 };
23921
23922 static const struct ndr_interface_string_array spoolss_endpoints = {
23923         .count  = 1,
23924         .names  = spoolss_endpoint_strings
23925 };
23926
23927 static const char * const spoolss_authservice_strings[] = {
23928         "host",
23929 };
23930
23931 static const struct ndr_interface_string_array spoolss_authservices = {
23932         .count  = 1,
23933         .names  = spoolss_authservice_strings
23934 };
23935
23936
23937 const struct ndr_interface_table ndr_table_spoolss = {
23938         .name           = "spoolss",
23939         .syntax_id      = {
23940                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
23941                 NDR_SPOOLSS_VERSION
23942         },
23943         .helpstring     = NDR_SPOOLSS_HELPSTRING,
23944         .num_calls      = 96,
23945         .calls          = spoolss_calls,
23946         .endpoints      = &spoolss_endpoints,
23947         .authservices   = &spoolss_authservices
23948 };
23949