librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 228 {
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_push_align(ndr, 4));
 231                 {
 232                         uint32_t _flags_save_string = ndr->flags;
 233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 235                         ndr->flags = _flags_save_string;
 236                 }
 237                 {
 238                         uint32_t _flags_save_string = ndr->flags;
 239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 241                         ndr->flags = _flags_save_string;
 242                 }
 243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 246                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
 257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 258                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 265                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 270         }
 271         if (ndr_flags & NDR_BUFFERS) {
 272                 {
 273                         uint32_t _flags_save_string = ndr->flags;
 274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 275                         if (r->printername) {
 276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 278                         }
 279                         ndr->flags = _flags_save_string;
 280                 }
 281                 {
 282                         uint32_t _flags_save_string = ndr->flags;
 283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 284                         if (r->servername) {
 285                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 286                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 287                         }
 288                         ndr->flags = _flags_save_string;
 289                 }
 290         }
 291         return NDR_ERR_SUCCESS;
 292 }
 293
 294 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 295 {
 296         uint32_t _ptr_printername;
 297         TALLOC_CTX *_mem_save_printername_0;
 298         uint32_t _ptr_servername;
 299         TALLOC_CTX *_mem_save_servername_0;
 300         if (ndr_flags & NDR_SCALARS) {
 301                 NDR_CHECK(ndr_pull_align(ndr, 4));
 302                 {
 303                         uint32_t _flags_save_string = ndr->flags;
 304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 306                         if (_ptr_printername) {
 307                                 NDR_PULL_ALLOC(ndr, r->printername);
 308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 309                         } else {
 310                                 r->printername = NULL;
 311                         }
 312                         ndr->flags = _flags_save_string;
 313                 }
 314                 {
 315                         uint32_t _flags_save_string = ndr->flags;
 316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 318                         if (_ptr_servername) {
 319                                 NDR_PULL_ALLOC(ndr, r->servername);
 320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 321                         } else {
 322                                 r->servername = NULL;
 323                         }
 324                         ndr->flags = _flags_save_string;
 325                 }
 326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 329                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
 340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 341                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 348                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 349                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 353         }
 354         if (ndr_flags & NDR_BUFFERS) {
 355                 {
 356                         uint32_t _flags_save_string = ndr->flags;
 357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 358                         if (r->printername) {
 359                                 uint32_t _relative_save_offset;
 360                                 _relative_save_offset = ndr->offset;
 361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 362                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 363                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 366                                 ndr->offset = _relative_save_offset;
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370                 {
 371                         uint32_t _flags_save_string = ndr->flags;
 372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 373                         if (r->servername) {
 374                                 uint32_t _relative_save_offset;
 375                                 _relative_save_offset = ndr->offset;
 376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 377                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 378                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 379                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 381                                 ndr->offset = _relative_save_offset;
 382                         }
 383                         ndr->flags = _flags_save_string;
 384                 }
 385         }
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 390 {
 391         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 392         ndr->depth++;
 393         ndr_print_ptr(ndr, "printername", r->printername);
 394         ndr->depth++;
 395         if (r->printername) {
 396                 ndr_print_string(ndr, "printername", r->printername);
 397         }
 398         ndr->depth--;
 399         ndr_print_ptr(ndr, "servername", r->servername);
 400         ndr->depth++;
 401         if (r->servername) {
 402                 ndr_print_string(ndr, "servername", r->servername);
 403         }
 404         ndr->depth--;
 405         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 406         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 407         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 408         ndr_print_spoolss_Time(ndr, "time", &r->time);
 409         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 410         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 411         ndr_print_uint32(ndr, "version", r->version);
 412         ndr_print_uint32(ndr, "free_build", r->free_build);
 413         ndr_print_uint32(ndr, "spooling", r->spooling);
 414         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 415         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 416         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 417         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 418         ndr_print_uint32(ndr, "job_error", r->job_error);
 419         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 420         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 421         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 422         ndr_print_uint32(ndr, "change_id", r->change_id);
 423         ndr_print_WERROR(ndr, "last_error", r->last_error);
 424         ndr_print_uint32(ndr, "status", r->status);
 425         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 426         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 427         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 428         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 429         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 430         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 431         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 432         ndr->depth--;
 433 }
 434
 435 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 436 {
 437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 438         return NDR_ERR_SUCCESS;
 439 }
 440
 441 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 442 {
 443         uint32_t v;
 444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 445         *r = v;
 446         return NDR_ERR_SUCCESS;
 447 }
 448
 449 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 450 {
 451         ndr_print_uint32(ndr, name, r);
 452         ndr->depth++;
 453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 464         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 465         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 466         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 467         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 468         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 469         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 470         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 474         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 478         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 480         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 481         ndr->depth--;
 482 }
 483
 484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 485 {
 486         if (ndr_flags & NDR_SCALARS) {
 487                 NDR_CHECK(ndr_push_align(ndr, 4));
 488                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 489                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 490                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 491                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 492                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 493                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 494                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 496                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 497                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 498                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 499                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 500                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 501                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 502                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 503                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 504                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 505                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 506                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 507                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 508                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 522                 {
 523                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 525                         {
 526                                 struct ndr_push *_ndr_driverextra_data;
 527                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 528                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 529                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 530                         }
 531                         ndr->flags = _flags_save_DATA_BLOB;
 532                 }
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535         }
 536         return NDR_ERR_SUCCESS;
 537 }
 538
 539 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 540 {
 541         if (ndr_flags & NDR_SCALARS) {
 542                 NDR_CHECK(ndr_pull_align(ndr, 4));
 543                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 544                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 545                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 546                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 547                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 548                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 549                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 550                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 551                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 552                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 553                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 554                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 555                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 556                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 557                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 558                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 559                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 560                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 562                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 563                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 577                 {
 578                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 580                         {
 581                                 struct ndr_pull *_ndr_driverextra_data;
 582                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 583                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 584                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 585                         }
 586                         ndr->flags = _flags_save_DATA_BLOB;
 587                 }
 588         }
 589         if (ndr_flags & NDR_BUFFERS) {
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 595 {
 596         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 597         ndr->depth++;
 598         ndr_print_string(ndr, "devicename", r->devicename);
 599         ndr_print_uint16(ndr, "specversion", r->specversion);
 600         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 601         ndr_print_uint16(ndr, "size", r->size);
 602         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 603         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 604         ndr_print_uint16(ndr, "orientation", r->orientation);
 605         ndr_print_uint16(ndr, "papersize", r->papersize);
 606         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 607         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 608         ndr_print_uint16(ndr, "scale", r->scale);
 609         ndr_print_uint16(ndr, "copies", r->copies);
 610         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 611         ndr_print_uint16(ndr, "printquality", r->printquality);
 612         ndr_print_uint16(ndr, "color", r->color);
 613         ndr_print_uint16(ndr, "duplex", r->duplex);
 614         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 615         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 616         ndr_print_uint16(ndr, "collate", r->collate);
 617         ndr_print_string(ndr, "formname", r->formname);
 618         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 619         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 620         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 621         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 622         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 623         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 624         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 625         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 626         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 627         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 628         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 629         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 630         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 631         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 632         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 633         ndr->depth--;
 634 }
 635
 636 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 637 {
 638         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 639 }
 640
 641 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 642 {
 643         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 644         return NDR_ERR_SUCCESS;
 645 }
 646
 647 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 648 {
 649         uint32_t v;
 650         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 651         *r = v;
 652         return NDR_ERR_SUCCESS;
 653 }
 654
 655 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 656 {
 657         ndr_print_uint32(ndr, name, r);
 658         ndr->depth++;
 659         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 660         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 678         ndr->depth--;
 679 }
 680
 681 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 682 {
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_push_align(ndr, 4));
 685                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 686                 {
 687                         uint32_t _flags_save_string = ndr->flags;
 688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 689                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 690                         ndr->flags = _flags_save_string;
 691                 }
 692                 {
 693                         uint32_t _flags_save_string = ndr->flags;
 694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 695                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 696                         ndr->flags = _flags_save_string;
 697                 }
 698                 {
 699                         uint32_t _flags_save_string = ndr->flags;
 700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 701                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 702                         ndr->flags = _flags_save_string;
 703                 }
 704         }
 705         if (ndr_flags & NDR_BUFFERS) {
 706                 {
 707                         uint32_t _flags_save_string = ndr->flags;
 708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 709                         if (r->name) {
 710                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 712                         }
 713                         ndr->flags = _flags_save_string;
 714                 }
 715                 {
 716                         uint32_t _flags_save_string = ndr->flags;
 717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 718                         if (r->description) {
 719                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 720                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 721                         }
 722                         ndr->flags = _flags_save_string;
 723                 }
 724                 {
 725                         uint32_t _flags_save_string = ndr->flags;
 726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 727                         if (r->comment) {
 728                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 730                         }
 731                         ndr->flags = _flags_save_string;
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 738 {
 739         uint32_t _ptr_name;
 740         TALLOC_CTX *_mem_save_name_0;
 741         uint32_t _ptr_description;
 742         TALLOC_CTX *_mem_save_description_0;
 743         uint32_t _ptr_comment;
 744         TALLOC_CTX *_mem_save_comment_0;
 745         if (ndr_flags & NDR_SCALARS) {
 746                 NDR_CHECK(ndr_pull_align(ndr, 4));
 747                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 748                 {
 749                         uint32_t _flags_save_string = ndr->flags;
 750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 752                         if (_ptr_name) {
 753                                 NDR_PULL_ALLOC(ndr, r->name);
 754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 755                         } else {
 756                                 r->name = NULL;
 757                         }
 758                         ndr->flags = _flags_save_string;
 759                 }
 760                 {
 761                         uint32_t _flags_save_string = ndr->flags;
 762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 764                         if (_ptr_description) {
 765                                 NDR_PULL_ALLOC(ndr, r->description);
 766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 767                         } else {
 768                                 r->description = NULL;
 769                         }
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 776                         if (_ptr_comment) {
 777                                 NDR_PULL_ALLOC(ndr, r->comment);
 778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 779                         } else {
 780                                 r->comment = NULL;
 781                         }
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 uint32_t _relative_save_offset;
 791                                 _relative_save_offset = ndr->offset;
 792                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 793                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 795                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 796                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 797                                 ndr->offset = _relative_save_offset;
 798                         }
 799                         ndr->flags = _flags_save_string;
 800                 }
 801                 {
 802                         uint32_t _flags_save_string = ndr->flags;
 803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 804                         if (r->description) {
 805                                 uint32_t _relative_save_offset;
 806                                 _relative_save_offset = ndr->offset;
 807                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 808                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 809                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 810                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 811                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 812                                 ndr->offset = _relative_save_offset;
 813                         }
 814                         ndr->flags = _flags_save_string;
 815                 }
 816                 {
 817                         uint32_t _flags_save_string = ndr->flags;
 818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 819                         if (r->comment) {
 820                                 uint32_t _relative_save_offset;
 821                                 _relative_save_offset = ndr->offset;
 822                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 823                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 824                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 825                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 827                                 ndr->offset = _relative_save_offset;
 828                         }
 829                         ndr->flags = _flags_save_string;
 830                 }
 831         }
 832         return NDR_ERR_SUCCESS;
 833 }
 834
 835 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 836 {
 837         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 838         ndr->depth++;
 839         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 840         ndr_print_ptr(ndr, "name", r->name);
 841         ndr->depth++;
 842         if (r->name) {
 843                 ndr_print_string(ndr, "name", r->name);
 844         }
 845         ndr->depth--;
 846         ndr_print_ptr(ndr, "description", r->description);
 847         ndr->depth++;
 848         if (r->description) {
 849                 ndr_print_string(ndr, "description", r->description);
 850         }
 851         ndr->depth--;
 852         ndr_print_ptr(ndr, "comment", r->comment);
 853         ndr->depth++;
 854         if (r->comment) {
 855                 ndr_print_string(ndr, "comment", r->comment);
 856         }
 857         ndr->depth--;
 858         ndr->depth--;
 859 }
 860
 861 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 862 {
 863         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 868 {
 869         uint32_t v;
 870         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 871         *r = v;
 872         return NDR_ERR_SUCCESS;
 873 }
 874
 875 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 876 {
 877         ndr_print_uint32(ndr, name, r);
 878         ndr->depth++;
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 889         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 890         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 891         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 893         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 895         ndr->depth--;
 896 }
 897
 898 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 899 {
 900         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 901         return NDR_ERR_SUCCESS;
 902 }
 903
 904 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 905 {
 906         uint32_t v;
 907         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 908         *r = v;
 909         return NDR_ERR_SUCCESS;
 910 }
 911
 912 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 913 {
 914         ndr_print_uint32(ndr, name, r);
 915         ndr->depth++;
 916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 941         ndr->depth--;
 942 }
 943
 944 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 945 {
 946         if (ndr_flags & NDR_SCALARS) {
 947                 NDR_CHECK(ndr_push_align(ndr, 4));
 948                 {
 949                         uint32_t _flags_save_string = ndr->flags;
 950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 951                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 952                         ndr->flags = _flags_save_string;
 953                 }
 954                 {
 955                         uint32_t _flags_save_string = ndr->flags;
 956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 958                         ndr->flags = _flags_save_string;
 959                 }
 960                 {
 961                         uint32_t _flags_save_string = ndr->flags;
 962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 964                         ndr->flags = _flags_save_string;
 965                 }
 966                 {
 967                         uint32_t _flags_save_string = ndr->flags;
 968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
 970                         ndr->flags = _flags_save_string;
 971                 }
 972                 {
 973                         uint32_t _flags_save_string = ndr->flags;
 974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
 976                         ndr->flags = _flags_save_string;
 977                 }
 978                 {
 979                         uint32_t _flags_save_string = ndr->flags;
 980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 982                         ndr->flags = _flags_save_string;
 983                 }
 984                 {
 985                         uint32_t _flags_save_string = ndr->flags;
 986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
 988                         ndr->flags = _flags_save_string;
 989                 }
 990                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
 991                 {
 992                         uint32_t _flags_save_string = ndr->flags;
 993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 994                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
 995                         ndr->flags = _flags_save_string;
 996                 }
 997                 {
 998                         uint32_t _flags_save_string = ndr->flags;
 999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1000                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1001                         ndr->flags = _flags_save_string;
1002                 }
1003                 {
1004                         uint32_t _flags_save_string = ndr->flags;
1005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1007                         ndr->flags = _flags_save_string;
1008                 }
1009                 {
1010                         uint32_t _flags_save_string = ndr->flags;
1011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1013                         ndr->flags = _flags_save_string;
1014                 }
1015                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1016                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1021                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1024         }
1025         if (ndr_flags & NDR_BUFFERS) {
1026                 {
1027                         uint32_t _flags_save_string = ndr->flags;
1028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1029                         if (r->servername) {
1030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1032                         }
1033                         ndr->flags = _flags_save_string;
1034                 }
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         if (r->printername) {
1039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1041                         }
1042                         ndr->flags = _flags_save_string;
1043                 }
1044                 {
1045                         uint32_t _flags_save_string = ndr->flags;
1046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1047                         if (r->sharename) {
1048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1050                         }
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         if (r->portname) {
1057                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1058                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1059                         }
1060                         ndr->flags = _flags_save_string;
1061                 }
1062                 {
1063                         uint32_t _flags_save_string = ndr->flags;
1064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1065                         if (r->drivername) {
1066                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1067                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1068                         }
1069                         ndr->flags = _flags_save_string;
1070                 }
1071                 {
1072                         uint32_t _flags_save_string = ndr->flags;
1073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1074                         if (r->comment) {
1075                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1076                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1077                         }
1078                         ndr->flags = _flags_save_string;
1079                 }
1080                 {
1081                         uint32_t _flags_save_string = ndr->flags;
1082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1083                         if (r->location) {
1084                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1085                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1086                         }
1087                         ndr->flags = _flags_save_string;
1088                 }
1089                 if (r->devmode) {
1090                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1091                         {
1092                                 struct ndr_push *_ndr_devmode;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1094                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1096                         }
1097                 }
1098                 {
1099                         uint32_t _flags_save_string = ndr->flags;
1100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1101                         if (r->sepfile) {
1102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1104                         }
1105                         ndr->flags = _flags_save_string;
1106                 }
1107                 {
1108                         uint32_t _flags_save_string = ndr->flags;
1109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1110                         if (r->printprocessor) {
1111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1113                         }
1114                         ndr->flags = _flags_save_string;
1115                 }
1116                 {
1117                         uint32_t _flags_save_string = ndr->flags;
1118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1119                         if (r->datatype) {
1120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1122                         }
1123                         ndr->flags = _flags_save_string;
1124                 }
1125                 {
1126                         uint32_t _flags_save_string = ndr->flags;
1127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1128                         if (r->parameters) {
1129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1131                         }
1132                         ndr->flags = _flags_save_string;
1133                 }
1134                 if (r->secdesc) {
1135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1136                         {
1137                                 struct ndr_push *_ndr_secdesc;
1138                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1139                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1140                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1141                         }
1142                 }
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1148 {
1149         uint32_t _ptr_servername;
1150         TALLOC_CTX *_mem_save_servername_0;
1151         uint32_t _ptr_printername;
1152         TALLOC_CTX *_mem_save_printername_0;
1153         uint32_t _ptr_sharename;
1154         TALLOC_CTX *_mem_save_sharename_0;
1155         uint32_t _ptr_portname;
1156         TALLOC_CTX *_mem_save_portname_0;
1157         uint32_t _ptr_drivername;
1158         TALLOC_CTX *_mem_save_drivername_0;
1159         uint32_t _ptr_comment;
1160         TALLOC_CTX *_mem_save_comment_0;
1161         uint32_t _ptr_location;
1162         TALLOC_CTX *_mem_save_location_0;
1163         uint32_t _ptr_devmode;
1164         TALLOC_CTX *_mem_save_devmode_0;
1165         uint32_t _ptr_sepfile;
1166         TALLOC_CTX *_mem_save_sepfile_0;
1167         uint32_t _ptr_printprocessor;
1168         TALLOC_CTX *_mem_save_printprocessor_0;
1169         uint32_t _ptr_datatype;
1170         TALLOC_CTX *_mem_save_datatype_0;
1171         uint32_t _ptr_parameters;
1172         TALLOC_CTX *_mem_save_parameters_0;
1173         uint32_t _ptr_secdesc;
1174         TALLOC_CTX *_mem_save_secdesc_0;
1175         if (ndr_flags & NDR_SCALARS) {
1176                 NDR_CHECK(ndr_pull_align(ndr, 4));
1177                 {
1178                         uint32_t _flags_save_string = ndr->flags;
1179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1181                         if (_ptr_servername) {
1182                                 NDR_PULL_ALLOC(ndr, r->servername);
1183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1184                         } else {
1185                                 r->servername = NULL;
1186                         }
1187                         ndr->flags = _flags_save_string;
1188                 }
1189                 {
1190                         uint32_t _flags_save_string = ndr->flags;
1191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1193                         if (_ptr_printername) {
1194                                 NDR_PULL_ALLOC(ndr, r->printername);
1195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1196                         } else {
1197                                 r->printername = NULL;
1198                         }
1199                         ndr->flags = _flags_save_string;
1200                 }
1201                 {
1202                         uint32_t _flags_save_string = ndr->flags;
1203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1205                         if (_ptr_sharename) {
1206                                 NDR_PULL_ALLOC(ndr, r->sharename);
1207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1208                         } else {
1209                                 r->sharename = NULL;
1210                         }
1211                         ndr->flags = _flags_save_string;
1212                 }
1213                 {
1214                         uint32_t _flags_save_string = ndr->flags;
1215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1217                         if (_ptr_portname) {
1218                                 NDR_PULL_ALLOC(ndr, r->portname);
1219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1220                         } else {
1221                                 r->portname = NULL;
1222                         }
1223                         ndr->flags = _flags_save_string;
1224                 }
1225                 {
1226                         uint32_t _flags_save_string = ndr->flags;
1227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1229                         if (_ptr_drivername) {
1230                                 NDR_PULL_ALLOC(ndr, r->drivername);
1231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1232                         } else {
1233                                 r->drivername = NULL;
1234                         }
1235                         ndr->flags = _flags_save_string;
1236                 }
1237                 {
1238                         uint32_t _flags_save_string = ndr->flags;
1239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1241                         if (_ptr_comment) {
1242                                 NDR_PULL_ALLOC(ndr, r->comment);
1243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1244                         } else {
1245                                 r->comment = NULL;
1246                         }
1247                         ndr->flags = _flags_save_string;
1248                 }
1249                 {
1250                         uint32_t _flags_save_string = ndr->flags;
1251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1253                         if (_ptr_location) {
1254                                 NDR_PULL_ALLOC(ndr, r->location);
1255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1256                         } else {
1257                                 r->location = NULL;
1258                         }
1259                         ndr->flags = _flags_save_string;
1260                 }
1261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1262                 if (_ptr_devmode) {
1263                         NDR_PULL_ALLOC(ndr, r->devmode);
1264                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1265                 } else {
1266                         r->devmode = NULL;
1267                 }
1268                 {
1269                         uint32_t _flags_save_string = ndr->flags;
1270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1272                         if (_ptr_sepfile) {
1273                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1275                         } else {
1276                                 r->sepfile = NULL;
1277                         }
1278                         ndr->flags = _flags_save_string;
1279                 }
1280                 {
1281                         uint32_t _flags_save_string = ndr->flags;
1282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1284                         if (_ptr_printprocessor) {
1285                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1287                         } else {
1288                                 r->printprocessor = NULL;
1289                         }
1290                         ndr->flags = _flags_save_string;
1291                 }
1292                 {
1293                         uint32_t _flags_save_string = ndr->flags;
1294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1296                         if (_ptr_datatype) {
1297                                 NDR_PULL_ALLOC(ndr, r->datatype);
1298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1299                         } else {
1300                                 r->datatype = NULL;
1301                         }
1302                         ndr->flags = _flags_save_string;
1303                 }
1304                 {
1305                         uint32_t _flags_save_string = ndr->flags;
1306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1307                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1308                         if (_ptr_parameters) {
1309                                 NDR_PULL_ALLOC(ndr, r->parameters);
1310                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1311                         } else {
1312                                 r->parameters = NULL;
1313                         }
1314                         ndr->flags = _flags_save_string;
1315                 }
1316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1317                 if (_ptr_secdesc) {
1318                         NDR_PULL_ALLOC(ndr, r->secdesc);
1319                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1320                 } else {
1321                         r->secdesc = NULL;
1322                 }
1323                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1328                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1331         }
1332         if (ndr_flags & NDR_BUFFERS) {
1333                 {
1334                         uint32_t _flags_save_string = ndr->flags;
1335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1336                         if (r->servername) {
1337                                 uint32_t _relative_save_offset;
1338                                 _relative_save_offset = ndr->offset;
1339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1340                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1341                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1344                                 ndr->offset = _relative_save_offset;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         if (r->printername) {
1352                                 uint32_t _relative_save_offset;
1353                                 _relative_save_offset = ndr->offset;
1354                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1355                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1356                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1357                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1358                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1359                                 ndr->offset = _relative_save_offset;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 {
1364                         uint32_t _flags_save_string = ndr->flags;
1365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1366                         if (r->sharename) {
1367                                 uint32_t _relative_save_offset;
1368                                 _relative_save_offset = ndr->offset;
1369                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1370                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1371                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1372                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1373                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1374                                 ndr->offset = _relative_save_offset;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         if (r->portname) {
1382                                 uint32_t _relative_save_offset;
1383                                 _relative_save_offset = ndr->offset;
1384                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1385                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1386                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1387                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1388                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1389                                 ndr->offset = _relative_save_offset;
1390                         }
1391                         ndr->flags = _flags_save_string;
1392                 }
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->drivername) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1400                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1404                                 ndr->offset = _relative_save_offset;
1405                         }
1406                         ndr->flags = _flags_save_string;
1407                 }
1408                 {
1409                         uint32_t _flags_save_string = ndr->flags;
1410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1411                         if (r->comment) {
1412                                 uint32_t _relative_save_offset;
1413                                 _relative_save_offset = ndr->offset;
1414                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1415                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1416                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1417                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1418                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1419                                 ndr->offset = _relative_save_offset;
1420                         }
1421                         ndr->flags = _flags_save_string;
1422                 }
1423                 {
1424                         uint32_t _flags_save_string = ndr->flags;
1425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1426                         if (r->location) {
1427                                 uint32_t _relative_save_offset;
1428                                 _relative_save_offset = ndr->offset;
1429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1430                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1431                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1434                                 ndr->offset = _relative_save_offset;
1435                         }
1436                         ndr->flags = _flags_save_string;
1437                 }
1438                 if (r->devmode) {
1439                         uint32_t _relative_save_offset;
1440                         _relative_save_offset = ndr->offset;
1441                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1442                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1443                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1444                         {
1445                                 struct ndr_pull *_ndr_devmode;
1446                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1447                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1448                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1449                         }
1450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1451                         ndr->offset = _relative_save_offset;
1452                 }
1453                 {
1454                         uint32_t _flags_save_string = ndr->flags;
1455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1456                         if (r->sepfile) {
1457                                 uint32_t _relative_save_offset;
1458                                 _relative_save_offset = ndr->offset;
1459                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1460                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1461                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1462                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1463                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1464                                 ndr->offset = _relative_save_offset;
1465                         }
1466                         ndr->flags = _flags_save_string;
1467                 }
1468                 {
1469                         uint32_t _flags_save_string = ndr->flags;
1470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1471                         if (r->printprocessor) {
1472                                 uint32_t _relative_save_offset;
1473                                 _relative_save_offset = ndr->offset;
1474                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1475                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1476                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1477                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1478                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1479                                 ndr->offset = _relative_save_offset;
1480                         }
1481                         ndr->flags = _flags_save_string;
1482                 }
1483                 {
1484                         uint32_t _flags_save_string = ndr->flags;
1485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1486                         if (r->datatype) {
1487                                 uint32_t _relative_save_offset;
1488                                 _relative_save_offset = ndr->offset;
1489                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1490                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1491                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1492                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1493                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1494                                 ndr->offset = _relative_save_offset;
1495                         }
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         if (r->parameters) {
1502                                 uint32_t _relative_save_offset;
1503                                 _relative_save_offset = ndr->offset;
1504                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1505                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1506                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1507                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1508                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1509                                 ndr->offset = _relative_save_offset;
1510                         }
1511                         ndr->flags = _flags_save_string;
1512                 }
1513                 if (r->secdesc) {
1514                         uint32_t _relative_save_offset;
1515                         _relative_save_offset = ndr->offset;
1516                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1517                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1518                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1519                         {
1520                                 struct ndr_pull *_ndr_secdesc;
1521                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1522                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1523                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1524                         }
1525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1526                         ndr->offset = _relative_save_offset;
1527                 }
1528         }
1529         return NDR_ERR_SUCCESS;
1530 }
1531
1532 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1533 {
1534         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1535         ndr->depth++;
1536         ndr_print_ptr(ndr, "servername", r->servername);
1537         ndr->depth++;
1538         if (r->servername) {
1539                 ndr_print_string(ndr, "servername", r->servername);
1540         }
1541         ndr->depth--;
1542         ndr_print_ptr(ndr, "printername", r->printername);
1543         ndr->depth++;
1544         if (r->printername) {
1545                 ndr_print_string(ndr, "printername", r->printername);
1546         }
1547         ndr->depth--;
1548         ndr_print_ptr(ndr, "sharename", r->sharename);
1549         ndr->depth++;
1550         if (r->sharename) {
1551                 ndr_print_string(ndr, "sharename", r->sharename);
1552         }
1553         ndr->depth--;
1554         ndr_print_ptr(ndr, "portname", r->portname);
1555         ndr->depth++;
1556         if (r->portname) {
1557                 ndr_print_string(ndr, "portname", r->portname);
1558         }
1559         ndr->depth--;
1560         ndr_print_ptr(ndr, "drivername", r->drivername);
1561         ndr->depth++;
1562         if (r->drivername) {
1563                 ndr_print_string(ndr, "drivername", r->drivername);
1564         }
1565         ndr->depth--;
1566         ndr_print_ptr(ndr, "comment", r->comment);
1567         ndr->depth++;
1568         if (r->comment) {
1569                 ndr_print_string(ndr, "comment", r->comment);
1570         }
1571         ndr->depth--;
1572         ndr_print_ptr(ndr, "location", r->location);
1573         ndr->depth++;
1574         if (r->location) {
1575                 ndr_print_string(ndr, "location", r->location);
1576         }
1577         ndr->depth--;
1578         ndr_print_ptr(ndr, "devmode", r->devmode);
1579         ndr->depth++;
1580         if (r->devmode) {
1581                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1582         }
1583         ndr->depth--;
1584         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1585         ndr->depth++;
1586         if (r->sepfile) {
1587                 ndr_print_string(ndr, "sepfile", r->sepfile);
1588         }
1589         ndr->depth--;
1590         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1591         ndr->depth++;
1592         if (r->printprocessor) {
1593                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1594         }
1595         ndr->depth--;
1596         ndr_print_ptr(ndr, "datatype", r->datatype);
1597         ndr->depth++;
1598         if (r->datatype) {
1599                 ndr_print_string(ndr, "datatype", r->datatype);
1600         }
1601         ndr->depth--;
1602         ndr_print_ptr(ndr, "parameters", r->parameters);
1603         ndr->depth++;
1604         if (r->parameters) {
1605                 ndr_print_string(ndr, "parameters", r->parameters);
1606         }
1607         ndr->depth--;
1608         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1609         ndr->depth++;
1610         if (r->secdesc) {
1611                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1612         }
1613         ndr->depth--;
1614         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1615         ndr_print_uint32(ndr, "priority", r->priority);
1616         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1617         ndr_print_uint32(ndr, "starttime", r->starttime);
1618         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1619         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1620         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1621         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1622         ndr->depth--;
1623 }
1624
1625 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1626 {
1627         if (ndr_flags & NDR_SCALARS) {
1628                 NDR_CHECK(ndr_push_align(ndr, 4));
1629                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1630         }
1631         if (ndr_flags & NDR_BUFFERS) {
1632                 if (r->secdesc) {
1633                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1634                         {
1635                                 struct ndr_push *_ndr_secdesc;
1636                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1637                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1638                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1639                         }
1640                 }
1641         }
1642         return NDR_ERR_SUCCESS;
1643 }
1644
1645 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1646 {
1647         uint32_t _ptr_secdesc;
1648         TALLOC_CTX *_mem_save_secdesc_0;
1649         if (ndr_flags & NDR_SCALARS) {
1650                 NDR_CHECK(ndr_pull_align(ndr, 4));
1651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1652                 if (_ptr_secdesc) {
1653                         NDR_PULL_ALLOC(ndr, r->secdesc);
1654                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1655                 } else {
1656                         r->secdesc = NULL;
1657                 }
1658         }
1659         if (ndr_flags & NDR_BUFFERS) {
1660                 if (r->secdesc) {
1661                         uint32_t _relative_save_offset;
1662                         _relative_save_offset = ndr->offset;
1663                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1664                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1665                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1666                         {
1667                                 struct ndr_pull *_ndr_secdesc;
1668                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1669                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1670                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1671                         }
1672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1673                         ndr->offset = _relative_save_offset;
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1680 {
1681         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1682         ndr->depth++;
1683         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1684         ndr->depth++;
1685         if (r->secdesc) {
1686                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1687         }
1688         ndr->depth--;
1689         ndr->depth--;
1690 }
1691
1692 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1693 {
1694         if (ndr_flags & NDR_SCALARS) {
1695                 NDR_CHECK(ndr_push_align(ndr, 4));
1696                 {
1697                         uint32_t _flags_save_string = ndr->flags;
1698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1700                         ndr->flags = _flags_save_string;
1701                 }
1702                 {
1703                         uint32_t _flags_save_string = ndr->flags;
1704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1705                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1706                         ndr->flags = _flags_save_string;
1707                 }
1708                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1709         }
1710         if (ndr_flags & NDR_BUFFERS) {
1711                 {
1712                         uint32_t _flags_save_string = ndr->flags;
1713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1714                         if (r->printername) {
1715                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1716                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1717                         }
1718                         ndr->flags = _flags_save_string;
1719                 }
1720                 {
1721                         uint32_t _flags_save_string = ndr->flags;
1722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1723                         if (r->servername) {
1724                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1725                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1726                         }
1727                         ndr->flags = _flags_save_string;
1728                 }
1729         }
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1734 {
1735         uint32_t _ptr_printername;
1736         TALLOC_CTX *_mem_save_printername_0;
1737         uint32_t _ptr_servername;
1738         TALLOC_CTX *_mem_save_servername_0;
1739         if (ndr_flags & NDR_SCALARS) {
1740                 NDR_CHECK(ndr_pull_align(ndr, 4));
1741                 {
1742                         uint32_t _flags_save_string = ndr->flags;
1743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1745                         if (_ptr_printername) {
1746                                 NDR_PULL_ALLOC(ndr, r->printername);
1747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1748                         } else {
1749                                 r->printername = NULL;
1750                         }
1751                         ndr->flags = _flags_save_string;
1752                 }
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1757                         if (_ptr_servername) {
1758                                 NDR_PULL_ALLOC(ndr, r->servername);
1759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1760                         } else {
1761                                 r->servername = NULL;
1762                         }
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 uint32_t _relative_save_offset;
1773                                 _relative_save_offset = ndr->offset;
1774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1775                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1776                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1779                                 ndr->offset = _relative_save_offset;
1780                         }
1781                         ndr->flags = _flags_save_string;
1782                 }
1783                 {
1784                         uint32_t _flags_save_string = ndr->flags;
1785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1786                         if (r->servername) {
1787                                 uint32_t _relative_save_offset;
1788                                 _relative_save_offset = ndr->offset;
1789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1790                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1791                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1794                                 ndr->offset = _relative_save_offset;
1795                         }
1796                         ndr->flags = _flags_save_string;
1797                 }
1798         }
1799         return NDR_ERR_SUCCESS;
1800 }
1801
1802 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1803 {
1804         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1805         ndr->depth++;
1806         ndr_print_ptr(ndr, "printername", r->printername);
1807         ndr->depth++;
1808         if (r->printername) {
1809                 ndr_print_string(ndr, "printername", r->printername);
1810         }
1811         ndr->depth--;
1812         ndr_print_ptr(ndr, "servername", r->servername);
1813         ndr->depth++;
1814         if (r->servername) {
1815                 ndr_print_string(ndr, "servername", r->servername);
1816         }
1817         ndr->depth--;
1818         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1819         ndr->depth--;
1820 }
1821
1822 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1823 {
1824         if (ndr_flags & NDR_SCALARS) {
1825                 NDR_CHECK(ndr_push_align(ndr, 4));
1826                 {
1827                         uint32_t _flags_save_string = ndr->flags;
1828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1830                         ndr->flags = _flags_save_string;
1831                 }
1832                 {
1833                         uint32_t _flags_save_string = ndr->flags;
1834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1841         }
1842         if (ndr_flags & NDR_BUFFERS) {
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         if (r->printername) {
1847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1848                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1849                         }
1850                         ndr->flags = _flags_save_string;
1851                 }
1852                 {
1853                         uint32_t _flags_save_string = ndr->flags;
1854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1855                         if (r->portname) {
1856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1858                         }
1859                         ndr->flags = _flags_save_string;
1860                 }
1861         }
1862         return NDR_ERR_SUCCESS;
1863 }
1864
1865 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1866 {
1867         uint32_t _ptr_printername;
1868         TALLOC_CTX *_mem_save_printername_0;
1869         uint32_t _ptr_portname;
1870         TALLOC_CTX *_mem_save_portname_0;
1871         if (ndr_flags & NDR_SCALARS) {
1872                 NDR_CHECK(ndr_pull_align(ndr, 4));
1873                 {
1874                         uint32_t _flags_save_string = ndr->flags;
1875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1877                         if (_ptr_printername) {
1878                                 NDR_PULL_ALLOC(ndr, r->printername);
1879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1880                         } else {
1881                                 r->printername = NULL;
1882                         }
1883                         ndr->flags = _flags_save_string;
1884                 }
1885                 {
1886                         uint32_t _flags_save_string = ndr->flags;
1887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1889                         if (_ptr_portname) {
1890                                 NDR_PULL_ALLOC(ndr, r->portname);
1891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1892                         } else {
1893                                 r->portname = NULL;
1894                         }
1895                         ndr->flags = _flags_save_string;
1896                 }
1897                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 {
1903                         uint32_t _flags_save_string = ndr->flags;
1904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1905                         if (r->printername) {
1906                                 uint32_t _relative_save_offset;
1907                                 _relative_save_offset = ndr->offset;
1908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1909                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1910                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1913                                 ndr->offset = _relative_save_offset;
1914                         }
1915                         ndr->flags = _flags_save_string;
1916                 }
1917                 {
1918                         uint32_t _flags_save_string = ndr->flags;
1919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1920                         if (r->portname) {
1921                                 uint32_t _relative_save_offset;
1922                                 _relative_save_offset = ndr->offset;
1923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1924                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1925                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1928                                 ndr->offset = _relative_save_offset;
1929                         }
1930                         ndr->flags = _flags_save_string;
1931                 }
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1937 {
1938         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1939         ndr->depth++;
1940         ndr_print_ptr(ndr, "printername", r->printername);
1941         ndr->depth++;
1942         if (r->printername) {
1943                 ndr_print_string(ndr, "printername", r->printername);
1944         }
1945         ndr->depth--;
1946         ndr_print_ptr(ndr, "portname", r->portname);
1947         ndr->depth++;
1948         if (r->portname) {
1949                 ndr_print_string(ndr, "portname", r->portname);
1950         }
1951         ndr->depth--;
1952         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1953         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1954         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1955         ndr->depth--;
1956 }
1957
1958 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1959 {
1960         if (ndr_flags & NDR_SCALARS) {
1961                 NDR_CHECK(ndr_push_align(ndr, 4));
1962                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1963         }
1964         if (ndr_flags & NDR_BUFFERS) {
1965         }
1966         return NDR_ERR_SUCCESS;
1967 }
1968
1969 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
1970 {
1971         if (ndr_flags & NDR_SCALARS) {
1972                 NDR_CHECK(ndr_pull_align(ndr, 4));
1973                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976         }
1977         return NDR_ERR_SUCCESS;
1978 }
1979
1980 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
1981 {
1982         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
1983         ndr->depth++;
1984         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1985         ndr->depth--;
1986 }
1987
1988 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1989 {
1990         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1991         return NDR_ERR_SUCCESS;
1992 }
1993
1994 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1995 {
1996         uint32_t v;
1997         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1998         *r = v;
1999         return NDR_ERR_SUCCESS;
2000 }
2001
2002 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2003 {
2004         ndr_print_uint32(ndr, name, r);
2005         ndr->depth++;
2006         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2007         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2008         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2009         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2010         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2011         ndr->depth--;
2012 }
2013
2014 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2015 {
2016         if (ndr_flags & NDR_SCALARS) {
2017                 NDR_CHECK(ndr_push_align(ndr, 4));
2018                 {
2019                         uint32_t _flags_save_string = ndr->flags;
2020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2022                         ndr->flags = _flags_save_string;
2023                 }
2024                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2025         }
2026         if (ndr_flags & NDR_BUFFERS) {
2027                 {
2028                         uint32_t _flags_save_string = ndr->flags;
2029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2030                         if (r->guid) {
2031                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2032                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2033                         }
2034                         ndr->flags = _flags_save_string;
2035                 }
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2041 {
2042         uint32_t _ptr_guid;
2043         TALLOC_CTX *_mem_save_guid_0;
2044         if (ndr_flags & NDR_SCALARS) {
2045                 NDR_CHECK(ndr_pull_align(ndr, 4));
2046                 {
2047                         uint32_t _flags_save_string = ndr->flags;
2048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2050                         if (_ptr_guid) {
2051                                 NDR_PULL_ALLOC(ndr, r->guid);
2052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2053                         } else {
2054                                 r->guid = NULL;
2055                         }
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 uint32_t _relative_save_offset;
2066                                 _relative_save_offset = ndr->offset;
2067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2068                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2069                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2072                                 ndr->offset = _relative_save_offset;
2073                         }
2074                         ndr->flags = _flags_save_string;
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2081 {
2082         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2083         ndr->depth++;
2084         ndr_print_ptr(ndr, "guid", r->guid);
2085         ndr->depth++;
2086         if (r->guid) {
2087                 ndr_print_string(ndr, "guid", r->guid);
2088         }
2089         ndr->depth--;
2090         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2091         ndr->depth--;
2092 }
2093
2094 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2095 {
2096         if (ndr_flags & NDR_SCALARS) {
2097                 NDR_CHECK(ndr_push_align(ndr, 4));
2098                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2099         }
2100         if (ndr_flags & NDR_BUFFERS) {
2101                 if (r->devmode) {
2102                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2103                         {
2104                                 struct ndr_push *_ndr_devmode;
2105                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2106                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2107                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2108                         }
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2115 {
2116         uint32_t _ptr_devmode;
2117         TALLOC_CTX *_mem_save_devmode_0;
2118         if (ndr_flags & NDR_SCALARS) {
2119                 NDR_CHECK(ndr_pull_align(ndr, 4));
2120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2121                 if (_ptr_devmode) {
2122                         NDR_PULL_ALLOC(ndr, r->devmode);
2123                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2124                 } else {
2125                         r->devmode = NULL;
2126                 }
2127         }
2128         if (ndr_flags & NDR_BUFFERS) {
2129                 if (r->devmode) {
2130                         uint32_t _relative_save_offset;
2131                         _relative_save_offset = ndr->offset;
2132                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2133                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2134                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2135                         {
2136                                 struct ndr_pull *_ndr_devmode;
2137                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2138                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2139                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2140                         }
2141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2142                         ndr->offset = _relative_save_offset;
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2149 {
2150         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2151         ndr->depth++;
2152         ndr_print_ptr(ndr, "devmode", r->devmode);
2153         ndr->depth++;
2154         if (r->devmode) {
2155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2156         }
2157         ndr->depth--;
2158         ndr->depth--;
2159 }
2160
2161 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2162 {
2163         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2164         if (ndr_flags & NDR_SCALARS) {
2165                 int level = ndr_push_get_switch_value(ndr, r);
2166                 switch (level) {
2167                         case 0: {
2168                                 NDR_CHECK(ndr_push_align(ndr, 4));
2169                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2170                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2171                         break; }
2172
2173                         case 1: {
2174                                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2176                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2177                         break; }
2178
2179                         case 2: {
2180                                 NDR_CHECK(ndr_push_align(ndr, 4));
2181                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2182                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2183                         break; }
2184
2185                         case 3: {
2186                                 NDR_CHECK(ndr_push_align(ndr, 4));
2187                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2188                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2189                         break; }
2190
2191                         case 4: {
2192                                 NDR_CHECK(ndr_push_align(ndr, 4));
2193                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2194                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2195                         break; }
2196
2197                         case 5: {
2198                                 NDR_CHECK(ndr_push_align(ndr, 4));
2199                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2200                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2201                         break; }
2202
2203                         case 6: {
2204                                 NDR_CHECK(ndr_push_align(ndr, 4));
2205                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2206                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2207                         break; }
2208
2209                         case 7: {
2210                                 NDR_CHECK(ndr_push_align(ndr, 4));
2211                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2212                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2213                         break; }
2214
2215                         case 8: {
2216                                 NDR_CHECK(ndr_push_align(ndr, 4));
2217                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2218                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2219                         break; }
2220
2221                         case 9: {
2222                                 NDR_CHECK(ndr_push_align(ndr, 4));
2223                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2224                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2225                         break; }
2226
2227                         default: {
2228                         break; }
2229
2230                 }
2231         }
2232         if (ndr_flags & NDR_BUFFERS) {
2233                 int level = ndr_push_get_switch_value(ndr, r);
2234                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2235                 switch (level) {
2236                         case 0:
2237                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2238                         break;
2239
2240                         case 1:
2241                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2242                         break;
2243
2244                         case 2:
2245                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2246                         break;
2247
2248                         case 3:
2249                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2250                         break;
2251
2252                         case 4:
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2254                         break;
2255
2256                         case 5:
2257                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2258                         break;
2259
2260                         case 6:
2261                         break;
2262
2263                         case 7:
2264                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2265                         break;
2266
2267                         case 8:
2268                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2269                         break;
2270
2271                         case 9:
2272                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2273                         break;
2274
2275                         default:
2276                         break;
2277
2278                 }
2279         }
2280         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2281         return NDR_ERR_SUCCESS;
2282 }
2283
2284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2285 {
2286         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2287         int level;
2288         level = ndr_pull_get_switch_value(ndr, r);
2289         if (ndr_flags & NDR_SCALARS) {
2290                 switch (level) {
2291                         case 0: {
2292                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2293                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2294                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2295                         break; }
2296
2297                         case 1: {
2298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2300                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2301                         break; }
2302
2303                         case 2: {
2304                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2305                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2306                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2307                         break; }
2308
2309                         case 3: {
2310                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2311                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2312                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2313                         break; }
2314
2315                         case 4: {
2316                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2317                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2318                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2319                         break; }
2320
2321                         case 5: {
2322                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2323                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2324                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2325                         break; }
2326
2327                         case 6: {
2328                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2329                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2330                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2331                         break; }
2332
2333                         case 7: {
2334                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2335                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2336                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2337                         break; }
2338
2339                         case 8: {
2340                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2341                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2342                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2343                         break; }
2344
2345                         case 9: {
2346                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2347                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2348                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2349                         break; }
2350
2351                         default: {
2352                         break; }
2353
2354                 }
2355         }
2356         if (ndr_flags & NDR_BUFFERS) {
2357                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2358                 switch (level) {
2359                         case 0:
2360                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2361                         break;
2362
2363                         case 1:
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2365                         break;
2366
2367                         case 2:
2368                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2369                         break;
2370
2371                         case 3:
2372                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2373                         break;
2374
2375                         case 4:
2376                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2377                         break;
2378
2379                         case 5:
2380                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2381                         break;
2382
2383                         case 6:
2384                         break;
2385
2386                         case 7:
2387                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2388                         break;
2389
2390                         case 8:
2391                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2392                         break;
2393
2394                         case 9:
2395                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2396                         break;
2397
2398                         default:
2399                         break;
2400
2401                 }
2402         }
2403         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2408 {
2409         int level;
2410         level = ndr_print_get_switch_value(ndr, r);
2411         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2412         switch (level) {
2413                 case 0:
2414                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2415                 break;
2416
2417                 case 1:
2418                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2419                 break;
2420
2421                 case 2:
2422                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2423                 break;
2424
2425                 case 3:
2426                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2427                 break;
2428
2429                 case 4:
2430                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2431                 break;
2432
2433                 case 5:
2434                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2435                 break;
2436
2437                 case 6:
2438                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2439                 break;
2440
2441                 case 7:
2442                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2443                 break;
2444
2445                 case 8:
2446                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2447                 break;
2448
2449                 case 9:
2450                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2451                 break;
2452
2453                 default:
2454                 break;
2455
2456         }
2457 }
2458
2459 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2460 {
2461         if (ndr_flags & NDR_SCALARS) {
2462                 NDR_CHECK(ndr_push_align(ndr, 4));
2463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2465         }
2466         if (ndr_flags & NDR_BUFFERS) {
2467                 if (r->devmode) {
2468                         {
2469                                 struct ndr_push *_ndr_devmode;
2470                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2471                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2472                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2473                         }
2474                 }
2475         }
2476         return NDR_ERR_SUCCESS;
2477 }
2478
2479 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2480 {
2481         uint32_t _ptr_devmode;
2482         TALLOC_CTX *_mem_save_devmode_0;
2483         if (ndr_flags & NDR_SCALARS) {
2484                 NDR_CHECK(ndr_pull_align(ndr, 4));
2485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2487                 if (_ptr_devmode) {
2488                         NDR_PULL_ALLOC(ndr, r->devmode);
2489                 } else {
2490                         r->devmode = NULL;
2491                 }
2492         }
2493         if (ndr_flags & NDR_BUFFERS) {
2494                 if (r->devmode) {
2495                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2497                         {
2498                                 struct ndr_pull *_ndr_devmode;
2499                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2500                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2501                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2502                         }
2503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2504                 }
2505         }
2506         return NDR_ERR_SUCCESS;
2507 }
2508
2509 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2510 {
2511         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2512         ndr->depth++;
2513         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2514         ndr_print_ptr(ndr, "devmode", r->devmode);
2515         ndr->depth++;
2516         if (r->devmode) {
2517                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2518         }
2519         ndr->depth--;
2520         ndr->depth--;
2521 }
2522
2523 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2524 {
2525         if (ndr_flags & NDR_SCALARS) {
2526                 NDR_CHECK(ndr_push_align(ndr, 4));
2527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2528                 {
2529                         uint32_t _flags_save_string = ndr->flags;
2530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2532                         ndr->flags = _flags_save_string;
2533                 }
2534                 {
2535                         uint32_t _flags_save_string = ndr->flags;
2536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2538                         ndr->flags = _flags_save_string;
2539                 }
2540                 {
2541                         uint32_t _flags_save_string = ndr->flags;
2542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2544                         ndr->flags = _flags_save_string;
2545                 }
2546                 {
2547                         uint32_t _flags_save_string = ndr->flags;
2548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2550                         ndr->flags = _flags_save_string;
2551                 }
2552                 {
2553                         uint32_t _flags_save_string = ndr->flags;
2554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2556                         ndr->flags = _flags_save_string;
2557                 }
2558                 {
2559                         uint32_t _flags_save_string = ndr->flags;
2560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2562                         ndr->flags = _flags_save_string;
2563                 }
2564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
2565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2569                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2570         }
2571         if (ndr_flags & NDR_BUFFERS) {
2572                 {
2573                         uint32_t _flags_save_string = ndr->flags;
2574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2575                         if (r->printer_name) {
2576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2578                         }
2579                         ndr->flags = _flags_save_string;
2580                 }
2581                 {
2582                         uint32_t _flags_save_string = ndr->flags;
2583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2584                         if (r->server_name) {
2585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2587                         }
2588                         ndr->flags = _flags_save_string;
2589                 }
2590                 {
2591                         uint32_t _flags_save_string = ndr->flags;
2592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2593                         if (r->user_name) {
2594                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2596                         }
2597                         ndr->flags = _flags_save_string;
2598                 }
2599                 {
2600                         uint32_t _flags_save_string = ndr->flags;
2601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2602                         if (r->document_name) {
2603                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2605                         }
2606                         ndr->flags = _flags_save_string;
2607                 }
2608                 {
2609                         uint32_t _flags_save_string = ndr->flags;
2610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2611                         if (r->data_type) {
2612                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2613                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2614                         }
2615                         ndr->flags = _flags_save_string;
2616                 }
2617                 {
2618                         uint32_t _flags_save_string = ndr->flags;
2619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2620                         if (r->text_status) {
2621                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2622                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2623                         }
2624                         ndr->flags = _flags_save_string;
2625                 }
2626         }
2627         return NDR_ERR_SUCCESS;
2628 }
2629
2630 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2631 {
2632         uint32_t _ptr_printer_name;
2633         TALLOC_CTX *_mem_save_printer_name_0;
2634         uint32_t _ptr_server_name;
2635         TALLOC_CTX *_mem_save_server_name_0;
2636         uint32_t _ptr_user_name;
2637         TALLOC_CTX *_mem_save_user_name_0;
2638         uint32_t _ptr_document_name;
2639         TALLOC_CTX *_mem_save_document_name_0;
2640         uint32_t _ptr_data_type;
2641         TALLOC_CTX *_mem_save_data_type_0;
2642         uint32_t _ptr_text_status;
2643         TALLOC_CTX *_mem_save_text_status_0;
2644         if (ndr_flags & NDR_SCALARS) {
2645                 NDR_CHECK(ndr_pull_align(ndr, 4));
2646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2647                 {
2648                         uint32_t _flags_save_string = ndr->flags;
2649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2651                         if (_ptr_printer_name) {
2652                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2654                         } else {
2655                                 r->printer_name = NULL;
2656                         }
2657                         ndr->flags = _flags_save_string;
2658                 }
2659                 {
2660                         uint32_t _flags_save_string = ndr->flags;
2661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2663                         if (_ptr_server_name) {
2664                                 NDR_PULL_ALLOC(ndr, r->server_name);
2665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2666                         } else {
2667                                 r->server_name = NULL;
2668                         }
2669                         ndr->flags = _flags_save_string;
2670                 }
2671                 {
2672                         uint32_t _flags_save_string = ndr->flags;
2673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2675                         if (_ptr_user_name) {
2676                                 NDR_PULL_ALLOC(ndr, r->user_name);
2677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2678                         } else {
2679                                 r->user_name = NULL;
2680                         }
2681                         ndr->flags = _flags_save_string;
2682                 }
2683                 {
2684                         uint32_t _flags_save_string = ndr->flags;
2685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2687                         if (_ptr_document_name) {
2688                                 NDR_PULL_ALLOC(ndr, r->document_name);
2689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2690                         } else {
2691                                 r->document_name = NULL;
2692                         }
2693                         ndr->flags = _flags_save_string;
2694                 }
2695                 {
2696                         uint32_t _flags_save_string = ndr->flags;
2697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2699                         if (_ptr_data_type) {
2700                                 NDR_PULL_ALLOC(ndr, r->data_type);
2701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2702                         } else {
2703                                 r->data_type = NULL;
2704                         }
2705                         ndr->flags = _flags_save_string;
2706                 }
2707                 {
2708                         uint32_t _flags_save_string = ndr->flags;
2709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2710                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2711                         if (_ptr_text_status) {
2712                                 NDR_PULL_ALLOC(ndr, r->text_status);
2713                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2714                         } else {
2715                                 r->text_status = NULL;
2716                         }
2717                         ndr->flags = _flags_save_string;
2718                 }
2719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
2720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2724                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2725         }
2726         if (ndr_flags & NDR_BUFFERS) {
2727                 {
2728                         uint32_t _flags_save_string = ndr->flags;
2729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2730                         if (r->printer_name) {
2731                                 uint32_t _relative_save_offset;
2732                                 _relative_save_offset = ndr->offset;
2733                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2734                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2735                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2736                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2737                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2738                                 ndr->offset = _relative_save_offset;
2739                         }
2740                         ndr->flags = _flags_save_string;
2741                 }
2742                 {
2743                         uint32_t _flags_save_string = ndr->flags;
2744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2745                         if (r->server_name) {
2746                                 uint32_t _relative_save_offset;
2747                                 _relative_save_offset = ndr->offset;
2748                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2749                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2750                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2751                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2752                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2753                                 ndr->offset = _relative_save_offset;
2754                         }
2755                         ndr->flags = _flags_save_string;
2756                 }
2757                 {
2758                         uint32_t _flags_save_string = ndr->flags;
2759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2760                         if (r->user_name) {
2761                                 uint32_t _relative_save_offset;
2762                                 _relative_save_offset = ndr->offset;
2763                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2764                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2765                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2766                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2767                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2768                                 ndr->offset = _relative_save_offset;
2769                         }
2770                         ndr->flags = _flags_save_string;
2771                 }
2772                 {
2773                         uint32_t _flags_save_string = ndr->flags;
2774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2775                         if (r->document_name) {
2776                                 uint32_t _relative_save_offset;
2777                                 _relative_save_offset = ndr->offset;
2778                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2779                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2780                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2781                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2782                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2783                                 ndr->offset = _relative_save_offset;
2784                         }
2785                         ndr->flags = _flags_save_string;
2786                 }
2787                 {
2788                         uint32_t _flags_save_string = ndr->flags;
2789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2790                         if (r->data_type) {
2791                                 uint32_t _relative_save_offset;
2792                                 _relative_save_offset = ndr->offset;
2793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2794                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2795                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2798                                 ndr->offset = _relative_save_offset;
2799                         }
2800                         ndr->flags = _flags_save_string;
2801                 }
2802                 {
2803                         uint32_t _flags_save_string = ndr->flags;
2804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2805                         if (r->text_status) {
2806                                 uint32_t _relative_save_offset;
2807                                 _relative_save_offset = ndr->offset;
2808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2809                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2810                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2813                                 ndr->offset = _relative_save_offset;
2814                         }
2815                         ndr->flags = _flags_save_string;
2816                 }
2817         }
2818         return NDR_ERR_SUCCESS;
2819 }
2820
2821 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2822 {
2823         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2824         ndr->depth++;
2825         ndr_print_uint32(ndr, "job_id", r->job_id);
2826         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2827         ndr->depth++;
2828         if (r->printer_name) {
2829                 ndr_print_string(ndr, "printer_name", r->printer_name);
2830         }
2831         ndr->depth--;
2832         ndr_print_ptr(ndr, "server_name", r->server_name);
2833         ndr->depth++;
2834         if (r->server_name) {
2835                 ndr_print_string(ndr, "server_name", r->server_name);
2836         }
2837         ndr->depth--;
2838         ndr_print_ptr(ndr, "user_name", r->user_name);
2839         ndr->depth++;
2840         if (r->user_name) {
2841                 ndr_print_string(ndr, "user_name", r->user_name);
2842         }
2843         ndr->depth--;
2844         ndr_print_ptr(ndr, "document_name", r->document_name);
2845         ndr->depth++;
2846         if (r->document_name) {
2847                 ndr_print_string(ndr, "document_name", r->document_name);
2848         }
2849         ndr->depth--;
2850         ndr_print_ptr(ndr, "data_type", r->data_type);
2851         ndr->depth++;
2852         if (r->data_type) {
2853                 ndr_print_string(ndr, "data_type", r->data_type);
2854         }
2855         ndr->depth--;
2856         ndr_print_ptr(ndr, "text_status", r->text_status);
2857         ndr->depth++;
2858         if (r->text_status) {
2859                 ndr_print_string(ndr, "text_status", r->text_status);
2860         }
2861         ndr->depth--;
2862         ndr_print_uint32(ndr, "status", r->status);
2863         ndr_print_uint32(ndr, "priority", r->priority);
2864         ndr_print_uint32(ndr, "position", r->position);
2865         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2866         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2867         ndr_print_spoolss_Time(ndr, "time", &r->time);
2868         ndr->depth--;
2869 }
2870
2871 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
2872 {
2873         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2874         if (ndr_flags & NDR_SCALARS) {
2875                 int level = ndr_push_get_switch_value(ndr, r);
2876                 switch (level) {
2877                         case 1: {
2878                                 NDR_CHECK(ndr_push_align(ndr, 4));
2879                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2880                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2881                         break; }
2882
2883                         case 2: {
2884                         break; }
2885
2886                         case 3: {
2887                         break; }
2888
2889                         default: {
2890                         break; }
2891
2892                 }
2893         }
2894         if (ndr_flags & NDR_BUFFERS) {
2895                 int level = ndr_push_get_switch_value(ndr, r);
2896                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2897                 switch (level) {
2898                         case 1:
2899                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2900                         break;
2901
2902                         case 2:
2903                         break;
2904
2905                         case 3:
2906                         break;
2907
2908                         default:
2909                         break;
2910
2911                 }
2912         }
2913         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2914         return NDR_ERR_SUCCESS;
2915 }
2916
2917 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
2918 {
2919         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2920         int level;
2921         level = ndr_pull_get_switch_value(ndr, r);
2922         if (ndr_flags & NDR_SCALARS) {
2923                 switch (level) {
2924                         case 1: {
2925                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2926                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2927                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2928                         break; }
2929
2930                         case 2: {
2931                         break; }
2932
2933                         case 3: {
2934                         break; }
2935
2936                         default: {
2937                         break; }
2938
2939                 }
2940         }
2941         if (ndr_flags & NDR_BUFFERS) {
2942                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2943                 switch (level) {
2944                         case 1:
2945                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2946                         break;
2947
2948                         case 2:
2949                         break;
2950
2951                         case 3:
2952                         break;
2953
2954                         default:
2955                         break;
2956
2957                 }
2958         }
2959         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2960         return NDR_ERR_SUCCESS;
2961 }
2962
2963 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
2964 {
2965         int level;
2966         level = ndr_print_get_switch_value(ndr, r);
2967         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
2968         switch (level) {
2969                 case 1:
2970                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
2971                 break;
2972
2973                 case 2:
2974                 break;
2975
2976                 case 3:
2977                 break;
2978
2979                 default:
2980                 break;
2981
2982         }
2983 }
2984
2985 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
2986 {
2987         if (ndr_flags & NDR_SCALARS) {
2988                 NDR_CHECK(ndr_push_align(ndr, 4));
2989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2990                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
2991                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
2992         }
2993         if (ndr_flags & NDR_BUFFERS) {
2994                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
2995         }
2996         return NDR_ERR_SUCCESS;
2997 }
2998
2999 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
3000 {
3001         if (ndr_flags & NDR_SCALARS) {
3002                 NDR_CHECK(ndr_pull_align(ndr, 4));
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3004                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
3005                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
3009         }
3010         return NDR_ERR_SUCCESS;
3011 }
3012
3013 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
3014 {
3015         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
3016         ndr->depth++;
3017         ndr_print_uint32(ndr, "level", r->level);
3018         ndr_print_set_switch_value(ndr, &r->info, r->level);
3019         ndr_print_spoolss_JobInfo(ndr, "info", &r->info);
3020         ndr->depth--;
3021 }
3022
3023 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
3024 {
3025         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3026         return NDR_ERR_SUCCESS;
3027 }
3028
3029 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
3030 {
3031         uint32_t v;
3032         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3033         *r = v;
3034         return NDR_ERR_SUCCESS;
3035 }
3036
3037 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
3038 {
3039         const char *val = NULL;
3040
3041         switch (r) {
3042                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
3043                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
3044                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
3045                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
3046                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
3047                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
3048                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
3049         }
3050         ndr_print_enum(ndr, name, "ENUM", val, r);
3051 }
3052
3053 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
3054 {
3055         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3056         return NDR_ERR_SUCCESS;
3057 }
3058
3059 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
3060 {
3061         uint32_t v;
3062         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3063         *r = v;
3064         return NDR_ERR_SUCCESS;
3065 }
3066
3067 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
3068 {
3069         const char *val = NULL;
3070
3071         switch (r) {
3072                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
3073                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
3074                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
3075                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
3076                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
3077         }
3078         ndr_print_enum(ndr, name, "ENUM", val, r);
3079 }
3080
3081 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
3082 {
3083         if (ndr_flags & NDR_SCALARS) {
3084                 NDR_CHECK(ndr_push_align(ndr, 4));
3085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
3089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
3090                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
3092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
3094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
3095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
3096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
3097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
3098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
3099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
3100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
3101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
3102                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
3103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
3104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
3105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
3106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
3107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
3108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
3109                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
3110                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
3111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
3112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
3113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
3114         }
3115         if (ndr_flags & NDR_BUFFERS) {
3116                 if (r->servername) {
3117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3121                 }
3122                 if (r->printername) {
3123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
3133 {
3134         uint32_t _ptr_servername;
3135         TALLOC_CTX *_mem_save_servername_0;
3136         uint32_t _ptr_printername;
3137         TALLOC_CTX *_mem_save_printername_0;
3138         if (ndr_flags & NDR_SCALARS) {
3139                 NDR_CHECK(ndr_pull_align(ndr, 4));
3140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3141                 if (_ptr_servername) {
3142                         NDR_PULL_ALLOC(ndr, r->servername);
3143                 } else {
3144                         r->servername = NULL;
3145                 }
3146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3147                 if (_ptr_printername) {
3148                         NDR_PULL_ALLOC(ndr, r->printername);
3149                 } else {
3150                         r->printername = NULL;
3151                 }
3152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
3154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
3155                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
3157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
3159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
3160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
3161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
3162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
3163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
3164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
3165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
3166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
3167                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
3168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
3169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
3170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
3171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
3172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
3173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
3174                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
3175                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
3176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
3177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
3178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
3179         }
3180         if (ndr_flags & NDR_BUFFERS) {
3181                 if (r->servername) {
3182                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3183                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3186                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3187                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3188                         }
3189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3192                 }
3193                 if (r->printername) {
3194                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3195                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3198                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3200                         }
3201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3204                 }
3205         }
3206         return NDR_ERR_SUCCESS;
3207 }
3208
3209 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
3210 {
3211         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
3212         ndr->depth++;
3213         ndr_print_ptr(ndr, "servername", r->servername);
3214         ndr->depth++;
3215         if (r->servername) {
3216                 ndr_print_string(ndr, "servername", r->servername);
3217         }
3218         ndr->depth--;
3219         ndr_print_ptr(ndr, "printername", r->printername);
3220         ndr->depth++;
3221         if (r->printername) {
3222                 ndr_print_string(ndr, "printername", r->printername);
3223         }
3224         ndr->depth--;
3225         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3226         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
3227         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
3228         ndr_print_spoolss_Time(ndr, "time", &r->time);
3229         ndr_print_uint32(ndr, "global_counter", r->global_counter);
3230         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3231         ndr_print_uint32(ndr, "version", r->version);
3232         ndr_print_uint32(ndr, "free_build", r->free_build);
3233         ndr_print_uint32(ndr, "spooling", r->spooling);
3234         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
3235         ndr_print_uint32(ndr, "session_counter", r->session_counter);
3236         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
3237         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
3238         ndr_print_uint32(ndr, "job_error", r->job_error);
3239         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
3240         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
3241         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
3242         ndr_print_uint32(ndr, "change_id", r->change_id);
3243         ndr_print_WERROR(ndr, "last_error", r->last_error);
3244         ndr_print_uint32(ndr, "status", r->status);
3245         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
3246         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
3247         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
3248         ndr_print_uint16(ndr, "processor_level", r->processor_level);
3249         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
3250         ndr_print_uint32(ndr, "reserved2", r->reserved2);
3251         ndr_print_uint32(ndr, "reserved3", r->reserved3);
3252         ndr->depth--;
3253 }
3254
3255 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
3256 {
3257         if (ndr_flags & NDR_SCALARS) {
3258                 NDR_CHECK(ndr_push_align(ndr, 4));
3259                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
3260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
3262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3263         }
3264         if (ndr_flags & NDR_BUFFERS) {
3265                 if (r->name) {
3266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3270                 }
3271                 if (r->description) {
3272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3276                 }
3277                 if (r->comment) {
3278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3282                 }
3283         }
3284         return NDR_ERR_SUCCESS;
3285 }
3286
3287 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
3288 {
3289         uint32_t _ptr_name;
3290         TALLOC_CTX *_mem_save_name_0;
3291         uint32_t _ptr_description;
3292         TALLOC_CTX *_mem_save_description_0;
3293         uint32_t _ptr_comment;
3294         TALLOC_CTX *_mem_save_comment_0;
3295         if (ndr_flags & NDR_SCALARS) {
3296                 NDR_CHECK(ndr_pull_align(ndr, 4));
3297                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3299                 if (_ptr_name) {
3300                         NDR_PULL_ALLOC(ndr, r->name);
3301                 } else {
3302                         r->name = NULL;
3303                 }
3304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
3305                 if (_ptr_description) {
3306                         NDR_PULL_ALLOC(ndr, r->description);
3307                 } else {
3308                         r->description = NULL;
3309                 }
3310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3311                 if (_ptr_comment) {
3312                         NDR_PULL_ALLOC(ndr, r->comment);
3313                 } else {
3314                         r->comment = NULL;
3315                 }
3316         }
3317         if (ndr_flags & NDR_BUFFERS) {
3318                 if (r->name) {
3319                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3320                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3323                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3324                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3325                         }
3326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3329                 }
3330                 if (r->description) {
3331                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
3332                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
3333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
3334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
3335                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
3336                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
3337                         }
3338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
3339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
3340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
3341                 }
3342                 if (r->comment) {
3343                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3347                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3349                         }
3350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3353                 }
3354         }
3355         return NDR_ERR_SUCCESS;
3356 }
3357
3358 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
3359 {
3360         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
3361         ndr->depth++;
3362         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
3363         ndr_print_ptr(ndr, "name", r->name);
3364         ndr->depth++;
3365         if (r->name) {
3366                 ndr_print_string(ndr, "name", r->name);
3367         }
3368         ndr->depth--;
3369         ndr_print_ptr(ndr, "description", r->description);
3370         ndr->depth++;
3371         if (r->description) {
3372                 ndr_print_string(ndr, "description", r->description);
3373         }
3374         ndr->depth--;
3375         ndr_print_ptr(ndr, "comment", r->comment);
3376         ndr->depth++;
3377         if (r->comment) {
3378                 ndr_print_string(ndr, "comment", r->comment);
3379         }
3380         ndr->depth--;
3381         ndr->depth--;
3382 }
3383
3384 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
3385 {
3386         if (ndr_flags & NDR_SCALARS) {
3387                 NDR_CHECK(ndr_push_align(ndr, 4));
3388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
3391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
3392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
3393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
3395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
3397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
3398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
3399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
3400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3401                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
3404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
3405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
3406                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
3407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
3409         }
3410         if (ndr_flags & NDR_BUFFERS) {
3411                 if (r->servername) {
3412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3416                 }
3417                 if (r->printername) {
3418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3422                 }
3423                 if (r->sharename) {
3424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3428                 }
3429                 if (r->portname) {
3430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3434                 }
3435                 if (r->drivername) {
3436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3440                 }
3441                 if (r->comment) {
3442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3446                 }
3447                 if (r->location) {
3448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3452                 }
3453                 if (r->devmode) {
3454                         {
3455                                 struct ndr_push *_ndr_devmode;
3456                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3457                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3458                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3459                         }
3460                 }
3461                 if (r->sepfile) {
3462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3465                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3466                 }
3467                 if (r->printprocessor) {
3468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3472                 }
3473                 if (r->datatype) {
3474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3478                 }
3479                 if (r->parameters) {
3480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3484                 }
3485                 if (r->secdesc) {
3486                         {
3487                                 struct ndr_push *_ndr_secdesc;
3488                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3489                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3490                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3491                         }
3492                 }
3493         }
3494         return NDR_ERR_SUCCESS;
3495 }
3496
3497 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
3498 {
3499         uint32_t _ptr_servername;
3500         TALLOC_CTX *_mem_save_servername_0;
3501         uint32_t _ptr_printername;
3502         TALLOC_CTX *_mem_save_printername_0;
3503         uint32_t _ptr_sharename;
3504         TALLOC_CTX *_mem_save_sharename_0;
3505         uint32_t _ptr_portname;
3506         TALLOC_CTX *_mem_save_portname_0;
3507         uint32_t _ptr_drivername;
3508         TALLOC_CTX *_mem_save_drivername_0;
3509         uint32_t _ptr_comment;
3510         TALLOC_CTX *_mem_save_comment_0;
3511         uint32_t _ptr_location;
3512         TALLOC_CTX *_mem_save_location_0;
3513         uint32_t _ptr_devmode;
3514         TALLOC_CTX *_mem_save_devmode_0;
3515         uint32_t _ptr_sepfile;
3516         TALLOC_CTX *_mem_save_sepfile_0;
3517         uint32_t _ptr_printprocessor;
3518         TALLOC_CTX *_mem_save_printprocessor_0;
3519         uint32_t _ptr_datatype;
3520         TALLOC_CTX *_mem_save_datatype_0;
3521         uint32_t _ptr_parameters;
3522         TALLOC_CTX *_mem_save_parameters_0;
3523         uint32_t _ptr_secdesc;
3524         TALLOC_CTX *_mem_save_secdesc_0;
3525         if (ndr_flags & NDR_SCALARS) {
3526                 NDR_CHECK(ndr_pull_align(ndr, 4));
3527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3528                 if (_ptr_servername) {
3529                         NDR_PULL_ALLOC(ndr, r->servername);
3530                 } else {
3531                         r->servername = NULL;
3532                 }
3533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3534                 if (_ptr_printername) {
3535                         NDR_PULL_ALLOC(ndr, r->printername);
3536                 } else {
3537                         r->printername = NULL;
3538                 }
3539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3540                 if (_ptr_sharename) {
3541                         NDR_PULL_ALLOC(ndr, r->sharename);
3542                 } else {
3543                         r->sharename = NULL;
3544                 }
3545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
3546                 if (_ptr_portname) {
3547                         NDR_PULL_ALLOC(ndr, r->portname);
3548                 } else {
3549                         r->portname = NULL;
3550                 }
3551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
3552                 if (_ptr_drivername) {
3553                         NDR_PULL_ALLOC(ndr, r->drivername);
3554                 } else {
3555                         r->drivername = NULL;
3556                 }
3557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3558                 if (_ptr_comment) {
3559                         NDR_PULL_ALLOC(ndr, r->comment);
3560                 } else {
3561                         r->comment = NULL;
3562                 }
3563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
3564                 if (_ptr_location) {
3565                         NDR_PULL_ALLOC(ndr, r->location);
3566                 } else {
3567                         r->location = NULL;
3568                 }
3569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3570                 if (_ptr_devmode) {
3571                         NDR_PULL_ALLOC(ndr, r->devmode);
3572                 } else {
3573                         r->devmode = NULL;
3574                 }
3575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
3576                 if (_ptr_sepfile) {
3577                         NDR_PULL_ALLOC(ndr, r->sepfile);
3578                 } else {
3579                         r->sepfile = NULL;
3580                 }
3581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
3582                 if (_ptr_printprocessor) {
3583                         NDR_PULL_ALLOC(ndr, r->printprocessor);
3584                 } else {
3585                         r->printprocessor = NULL;
3586                 }
3587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
3588                 if (_ptr_datatype) {
3589                         NDR_PULL_ALLOC(ndr, r->datatype);
3590                 } else {
3591                         r->datatype = NULL;
3592                 }
3593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3594                 if (_ptr_parameters) {
3595                         NDR_PULL_ALLOC(ndr, r->parameters);
3596                 } else {
3597                         r->parameters = NULL;
3598                 }
3599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3600                 if (_ptr_secdesc) {
3601                         NDR_PULL_ALLOC(ndr, r->secdesc);
3602                 } else {
3603                         r->secdesc = NULL;
3604                 }
3605                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
3609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
3610                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
3611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
3613         }
3614         if (ndr_flags & NDR_BUFFERS) {
3615                 if (r->servername) {
3616                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3617                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3620                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3621                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3622                         }
3623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3626                 }
3627                 if (r->printername) {
3628                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3629                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3632                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3633                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3634                         }
3635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3638                 }
3639                 if (r->sharename) {
3640                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3641                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
3642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
3643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
3644                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
3645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
3646                         }
3647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
3648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
3649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3650                 }
3651                 if (r->portname) {
3652                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3653                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
3654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
3655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
3656                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
3657                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
3658                         }
3659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
3660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
3661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
3662                 }
3663                 if (r->drivername) {
3664                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3665                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
3666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
3667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
3668                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
3669                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
3670                         }
3671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
3672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
3673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
3674                 }
3675                 if (r->comment) {
3676                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3677                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3680                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3681                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3682                         }
3683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3686                 }
3687                 if (r->location) {
3688                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
3689                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
3690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
3691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
3692                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
3693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
3694                         }
3695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
3696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
3697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
3698                 }
3699                 if (r->devmode) {
3700                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3701                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3702                         {
3703                                 struct ndr_pull *_ndr_devmode;
3704                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3705                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3706                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3707                         }
3708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3709                 }
3710                 if (r->sepfile) {
3711                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
3712                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
3713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
3714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
3715                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
3716                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
3717                         }
3718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
3719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
3720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
3721                 }
3722                 if (r->printprocessor) {
3723                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3724                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
3725                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
3726                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
3727                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
3728                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
3729                         }
3730                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
3731                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
3732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
3733                 }
3734                 if (r->datatype) {
3735                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
3736                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
3737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
3738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
3739                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
3740                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
3741                         }
3742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
3743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
3744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
3745                 }
3746                 if (r->parameters) {
3747                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3748                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3749                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
3750                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
3751                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
3752                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
3753                         }
3754                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
3755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
3756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3757                 }
3758                 if (r->secdesc) {
3759                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3760                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3761                         {
3762                                 struct ndr_pull *_ndr_secdesc;
3763                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3764                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3765                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3766                         }
3767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3768                 }
3769         }
3770         return NDR_ERR_SUCCESS;
3771 }
3772
3773 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
3774 {
3775         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
3776         ndr->depth++;
3777         ndr_print_ptr(ndr, "servername", r->servername);
3778         ndr->depth++;
3779         if (r->servername) {
3780                 ndr_print_string(ndr, "servername", r->servername);
3781         }
3782         ndr->depth--;
3783         ndr_print_ptr(ndr, "printername", r->printername);
3784         ndr->depth++;
3785         if (r->printername) {
3786                 ndr_print_string(ndr, "printername", r->printername);
3787         }
3788         ndr->depth--;
3789         ndr_print_ptr(ndr, "sharename", r->sharename);
3790         ndr->depth++;
3791         if (r->sharename) {
3792                 ndr_print_string(ndr, "sharename", r->sharename);
3793         }
3794         ndr->depth--;
3795         ndr_print_ptr(ndr, "portname", r->portname);
3796         ndr->depth++;
3797         if (r->portname) {
3798                 ndr_print_string(ndr, "portname", r->portname);
3799         }
3800         ndr->depth--;
3801         ndr_print_ptr(ndr, "drivername", r->drivername);
3802         ndr->depth++;
3803         if (r->drivername) {
3804                 ndr_print_string(ndr, "drivername", r->drivername);
3805         }
3806         ndr->depth--;
3807         ndr_print_ptr(ndr, "comment", r->comment);
3808         ndr->depth++;
3809         if (r->comment) {
3810                 ndr_print_string(ndr, "comment", r->comment);
3811         }
3812         ndr->depth--;
3813         ndr_print_ptr(ndr, "location", r->location);
3814         ndr->depth++;
3815         if (r->location) {
3816                 ndr_print_string(ndr, "location", r->location);
3817         }
3818         ndr->depth--;
3819         ndr_print_ptr(ndr, "devmode", r->devmode);
3820         ndr->depth++;
3821         if (r->devmode) {
3822                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3823         }
3824         ndr->depth--;
3825         ndr_print_ptr(ndr, "sepfile", r->sepfile);
3826         ndr->depth++;
3827         if (r->sepfile) {
3828                 ndr_print_string(ndr, "sepfile", r->sepfile);
3829         }
3830         ndr->depth--;
3831         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
3832         ndr->depth++;
3833         if (r->printprocessor) {
3834                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
3835         }
3836         ndr->depth--;
3837         ndr_print_ptr(ndr, "datatype", r->datatype);
3838         ndr->depth++;
3839         if (r->datatype) {
3840                 ndr_print_string(ndr, "datatype", r->datatype);
3841         }
3842         ndr->depth--;
3843         ndr_print_ptr(ndr, "parameters", r->parameters);
3844         ndr->depth++;
3845         if (r->parameters) {
3846                 ndr_print_string(ndr, "parameters", r->parameters);
3847         }
3848         ndr->depth--;
3849         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3850         ndr->depth++;
3851         if (r->secdesc) {
3852                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3853         }
3854         ndr->depth--;
3855         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
3856         ndr_print_uint32(ndr, "priority", r->priority);
3857         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
3858         ndr_print_uint32(ndr, "starttime", r->starttime);
3859         ndr_print_uint32(ndr, "untiltime", r->untiltime);
3860         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
3861         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3862         ndr_print_uint32(ndr, "averageppm", r->averageppm);
3863         ndr->depth--;
3864 }
3865
3866 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
3867 {
3868         if (ndr_flags & NDR_SCALARS) {
3869                 NDR_CHECK(ndr_push_align(ndr, 4));
3870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3871         }
3872         if (ndr_flags & NDR_BUFFERS) {
3873                 if (r->secdesc) {
3874                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3875                 }
3876         }
3877         return NDR_ERR_SUCCESS;
3878 }
3879
3880 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
3881 {
3882         uint32_t _ptr_secdesc;
3883         TALLOC_CTX *_mem_save_secdesc_0;
3884         if (ndr_flags & NDR_SCALARS) {
3885                 NDR_CHECK(ndr_pull_align(ndr, 4));
3886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3887                 if (_ptr_secdesc) {
3888                         NDR_PULL_ALLOC(ndr, r->secdesc);
3889                 } else {
3890                         r->secdesc = NULL;
3891                 }
3892         }
3893         if (ndr_flags & NDR_BUFFERS) {
3894                 if (r->secdesc) {
3895                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3896                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3897                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3899                 }
3900         }
3901         return NDR_ERR_SUCCESS;
3902 }
3903
3904 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
3905 {
3906         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
3907         ndr->depth++;
3908         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3909         ndr->depth++;
3910         if (r->secdesc) {
3911                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3912         }
3913         ndr->depth--;
3914         ndr->depth--;
3915 }
3916
3917 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
3918 {
3919         if (ndr_flags & NDR_SCALARS) {
3920                 NDR_CHECK(ndr_push_align(ndr, 4));
3921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3923                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3924         }
3925         if (ndr_flags & NDR_BUFFERS) {
3926                 if (r->printername) {
3927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3931                 }
3932                 if (r->servername) {
3933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3937                 }
3938         }
3939         return NDR_ERR_SUCCESS;
3940 }
3941
3942 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
3943 {
3944         uint32_t _ptr_printername;
3945         TALLOC_CTX *_mem_save_printername_0;
3946         uint32_t _ptr_servername;
3947         TALLOC_CTX *_mem_save_servername_0;
3948         if (ndr_flags & NDR_SCALARS) {
3949                 NDR_CHECK(ndr_pull_align(ndr, 4));
3950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3951                 if (_ptr_printername) {
3952                         NDR_PULL_ALLOC(ndr, r->printername);
3953                 } else {
3954                         r->printername = NULL;
3955                 }
3956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3957                 if (_ptr_servername) {
3958                         NDR_PULL_ALLOC(ndr, r->servername);
3959                 } else {
3960                         r->servername = NULL;
3961                 }
3962                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3963         }
3964         if (ndr_flags & NDR_BUFFERS) {
3965                 if (r->printername) {
3966                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3967                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3970                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3972                         }
3973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3976                 }
3977                 if (r->servername) {
3978                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3979                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3982                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3984                         }
3985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3988                 }
3989         }
3990         return NDR_ERR_SUCCESS;
3991 }
3992
3993 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
3994 {
3995         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
3996         ndr->depth++;
3997         ndr_print_ptr(ndr, "printername", r->printername);
3998         ndr->depth++;
3999         if (r->printername) {
4000                 ndr_print_string(ndr, "printername", r->printername);
4001         }
4002         ndr->depth--;
4003         ndr_print_ptr(ndr, "servername", r->servername);
4004         ndr->depth++;
4005         if (r->servername) {
4006                 ndr_print_string(ndr, "servername", r->servername);
4007         }
4008         ndr->depth--;
4009         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4010         ndr->depth--;
4011 }
4012
4013 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
4014 {
4015         if (ndr_flags & NDR_SCALARS) {
4016                 NDR_CHECK(ndr_push_align(ndr, 4));
4017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
4018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
4019                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
4020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
4021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
4022         }
4023         if (ndr_flags & NDR_BUFFERS) {
4024                 if (r->printername) {
4025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4029                 }
4030                 if (r->portname) {
4031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4035                 }
4036         }
4037         return NDR_ERR_SUCCESS;
4038 }
4039
4040 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
4041 {
4042         uint32_t _ptr_printername;
4043         TALLOC_CTX *_mem_save_printername_0;
4044         uint32_t _ptr_portname;
4045         TALLOC_CTX *_mem_save_portname_0;
4046         if (ndr_flags & NDR_SCALARS) {
4047                 NDR_CHECK(ndr_pull_align(ndr, 4));
4048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4049                 if (_ptr_printername) {
4050                         NDR_PULL_ALLOC(ndr, r->printername);
4051                 } else {
4052                         r->printername = NULL;
4053                 }
4054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
4055                 if (_ptr_portname) {
4056                         NDR_PULL_ALLOC(ndr, r->portname);
4057                 } else {
4058                         r->portname = NULL;
4059                 }
4060                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
4061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
4062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
4063         }
4064         if (ndr_flags & NDR_BUFFERS) {
4065                 if (r->printername) {
4066                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4067                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4070                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4071                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
4072                         }
4073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4076                 }
4077                 if (r->portname) {
4078                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
4079                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
4080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
4081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
4082                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
4083                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
4084                         }
4085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
4086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
4087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
4096         ndr->depth++;
4097         ndr_print_ptr(ndr, "printername", r->printername);
4098         ndr->depth++;
4099         if (r->printername) {
4100                 ndr_print_string(ndr, "printername", r->printername);
4101         }
4102         ndr->depth--;
4103         ndr_print_ptr(ndr, "portname", r->portname);
4104         ndr->depth++;
4105         if (r->portname) {
4106                 ndr_print_string(ndr, "portname", r->portname);
4107         }
4108         ndr->depth--;
4109         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4110         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
4111         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
4112         ndr->depth--;
4113 }
4114
4115 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
4116 {
4117         if (ndr_flags & NDR_SCALARS) {
4118                 NDR_CHECK(ndr_push_align(ndr, 4));
4119                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
4120         }
4121         if (ndr_flags & NDR_BUFFERS) {
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
4127 {
4128         if (ndr_flags & NDR_SCALARS) {
4129                 NDR_CHECK(ndr_pull_align(ndr, 4));
4130                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
4131         }
4132         if (ndr_flags & NDR_BUFFERS) {
4133         }
4134         return NDR_ERR_SUCCESS;
4135 }
4136
4137 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
4138 {
4139         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
4140         ndr->depth++;
4141         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
4142         ndr->depth--;
4143 }
4144
4145 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
4146 {
4147         if (ndr_flags & NDR_SCALARS) {
4148                 NDR_CHECK(ndr_push_align(ndr, 4));
4149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
4150                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
4151         }
4152         if (ndr_flags & NDR_BUFFERS) {
4153                 if (r->guid) {
4154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4158                 }
4159         }
4160         return NDR_ERR_SUCCESS;
4161 }
4162
4163 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
4164 {
4165         uint32_t _ptr_guid;
4166         TALLOC_CTX *_mem_save_guid_0;
4167         if (ndr_flags & NDR_SCALARS) {
4168                 NDR_CHECK(ndr_pull_align(ndr, 4));
4169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
4170                 if (_ptr_guid) {
4171                         NDR_PULL_ALLOC(ndr, r->guid);
4172                 } else {
4173                         r->guid = NULL;
4174                 }
4175                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
4176         }
4177         if (ndr_flags & NDR_BUFFERS) {
4178                 if (r->guid) {
4179                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4180                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
4181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
4182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
4183                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
4184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
4185                         }
4186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
4187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
4188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
4189                 }
4190         }
4191         return NDR_ERR_SUCCESS;
4192 }
4193
4194 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
4195 {
4196         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
4197         ndr->depth++;
4198         ndr_print_ptr(ndr, "guid", r->guid);
4199         ndr->depth++;
4200         if (r->guid) {
4201                 ndr_print_string(ndr, "guid", r->guid);
4202         }
4203         ndr->depth--;
4204         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
4205         ndr->depth--;
4206 }
4207
4208 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
4209 {
4210         if (ndr_flags & NDR_SCALARS) {
4211                 int level = ndr_push_get_switch_value(ndr, r);
4212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4213                 switch (level) {
4214                         case 0: {
4215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4216                         break; }
4217
4218                         case 1: {
4219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4220                         break; }
4221
4222                         case 2: {
4223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4224                         break; }
4225
4226                         case 3: {
4227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4228                         break; }
4229
4230                         case 4: {
4231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
4232                         break; }
4233
4234                         case 5: {
4235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
4236                         break; }
4237
4238                         case 6: {
4239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
4240                         break; }
4241
4242                         case 7: {
4243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
4244                         break; }
4245
4246                         case 8: {
4247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
4248                         break; }
4249
4250                         case 9: {
4251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
4252                         break; }
4253
4254                         default: {
4255                         break; }
4256
4257                 }
4258         }
4259         if (ndr_flags & NDR_BUFFERS) {
4260                 int level = ndr_push_get_switch_value(ndr, r);
4261                 switch (level) {
4262                         case 0:
4263                                 if (r->info0) {
4264                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4265                                 }
4266                         break;
4267
4268                         case 1:
4269                                 if (r->info1) {
4270                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4271                                 }
4272                         break;
4273
4274                         case 2:
4275                                 if (r->info2) {
4276                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4277                                 }
4278                         break;
4279
4280                         case 3:
4281                                 if (r->info3) {
4282                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4283                                 }
4284                         break;
4285
4286                         case 4:
4287                                 if (r->info4) {
4288                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4289                                 }
4290                         break;
4291
4292                         case 5:
4293                                 if (r->info5) {
4294                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4295                                 }
4296                         break;
4297
4298                         case 6:
4299                                 if (r->info6) {
4300                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4301                                 }
4302                         break;
4303
4304                         case 7:
4305                                 if (r->info7) {
4306                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4307                                 }
4308                         break;
4309
4310                         case 8:
4311                                 if (r->info8) {
4312                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4313                                 }
4314                         break;
4315
4316                         case 9:
4317                                 if (r->info9) {
4318                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4319                                 }
4320                         break;
4321
4322                         default:
4323                         break;
4324
4325                 }
4326         }
4327         return NDR_ERR_SUCCESS;
4328 }
4329
4330 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
4331 {
4332         int level;
4333         uint32_t _level;
4334         TALLOC_CTX *_mem_save_info0_0;
4335         TALLOC_CTX *_mem_save_info1_0;
4336         TALLOC_CTX *_mem_save_info2_0;
4337         TALLOC_CTX *_mem_save_info3_0;
4338         TALLOC_CTX *_mem_save_info4_0;
4339         TALLOC_CTX *_mem_save_info5_0;
4340         TALLOC_CTX *_mem_save_info6_0;
4341         TALLOC_CTX *_mem_save_info7_0;
4342         TALLOC_CTX *_mem_save_info8_0;
4343         TALLOC_CTX *_mem_save_info9_0;
4344         level = ndr_pull_get_switch_value(ndr, r);
4345         if (ndr_flags & NDR_SCALARS) {
4346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4347                 if (_level != level) {
4348                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4349                 }
4350                 switch (level) {
4351                         case 0: {
4352                                 uint32_t _ptr_info0;
4353                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4354                                 if (_ptr_info0) {
4355                                         NDR_PULL_ALLOC(ndr, r->info0);
4356                                 } else {
4357                                         r->info0 = NULL;
4358                                 }
4359                         break; }
4360
4361                         case 1: {
4362                                 uint32_t _ptr_info1;
4363                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4364                                 if (_ptr_info1) {
4365                                         NDR_PULL_ALLOC(ndr, r->info1);
4366                                 } else {
4367                                         r->info1 = NULL;
4368                                 }
4369                         break; }
4370
4371                         case 2: {
4372                                 uint32_t _ptr_info2;
4373                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4374                                 if (_ptr_info2) {
4375                                         NDR_PULL_ALLOC(ndr, r->info2);
4376                                 } else {
4377                                         r->info2 = NULL;
4378                                 }
4379                         break; }
4380
4381                         case 3: {
4382                                 uint32_t _ptr_info3;
4383                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4384                                 if (_ptr_info3) {
4385                                         NDR_PULL_ALLOC(ndr, r->info3);
4386                                 } else {
4387                                         r->info3 = NULL;
4388                                 }
4389                         break; }
4390
4391                         case 4: {
4392                                 uint32_t _ptr_info4;
4393                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
4394                                 if (_ptr_info4) {
4395                                         NDR_PULL_ALLOC(ndr, r->info4);
4396                                 } else {
4397                                         r->info4 = NULL;
4398                                 }
4399                         break; }
4400
4401                         case 5: {
4402                                 uint32_t _ptr_info5;
4403                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
4404                                 if (_ptr_info5) {
4405                                         NDR_PULL_ALLOC(ndr, r->info5);
4406                                 } else {
4407                                         r->info5 = NULL;
4408                                 }
4409                         break; }
4410
4411                         case 6: {
4412                                 uint32_t _ptr_info6;
4413                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
4414                                 if (_ptr_info6) {
4415                                         NDR_PULL_ALLOC(ndr, r->info6);
4416                                 } else {
4417                                         r->info6 = NULL;
4418                                 }
4419                         break; }
4420
4421                         case 7: {
4422                                 uint32_t _ptr_info7;
4423                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
4424                                 if (_ptr_info7) {
4425                                         NDR_PULL_ALLOC(ndr, r->info7);
4426                                 } else {
4427                                         r->info7 = NULL;
4428                                 }
4429                         break; }
4430
4431                         case 8: {
4432                                 uint32_t _ptr_info8;
4433                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
4434                                 if (_ptr_info8) {
4435                                         NDR_PULL_ALLOC(ndr, r->info8);
4436                                 } else {
4437                                         r->info8 = NULL;
4438                                 }
4439                         break; }
4440
4441                         case 9: {
4442                                 uint32_t _ptr_info9;
4443                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
4444                                 if (_ptr_info9) {
4445                                         NDR_PULL_ALLOC(ndr, r->info9);
4446                                 } else {
4447                                         r->info9 = NULL;
4448                                 }
4449                         break; }
4450
4451                         default: {
4452                         break; }
4453
4454                 }
4455         }
4456         if (ndr_flags & NDR_BUFFERS) {
4457                 switch (level) {
4458                         case 0:
4459                                 if (r->info0) {
4460                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4461                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4462                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4463                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4464                                 }
4465                         break;
4466
4467                         case 1:
4468                                 if (r->info1) {
4469                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4470                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4471                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4472                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4473                                 }
4474                         break;
4475
4476                         case 2:
4477                                 if (r->info2) {
4478                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4479                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4480                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4481                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4482                                 }
4483                         break;
4484
4485                         case 3:
4486                                 if (r->info3) {
4487                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4488                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4489                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4490                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4491                                 }
4492                         break;
4493
4494                         case 4:
4495                                 if (r->info4) {
4496                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
4497                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
4498                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4499                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
4500                                 }
4501                         break;
4502
4503                         case 5:
4504                                 if (r->info5) {
4505                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
4506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
4507                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
4509                                 }
4510                         break;
4511
4512                         case 6:
4513                                 if (r->info6) {
4514                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
4515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
4516                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
4518                                 }
4519                         break;
4520
4521                         case 7:
4522                                 if (r->info7) {
4523                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
4524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
4525                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
4527                                 }
4528                         break;
4529
4530                         case 8:
4531                                 if (r->info8) {
4532                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
4534                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
4536                                 }
4537                         break;
4538
4539                         case 9:
4540                                 if (r->info9) {
4541                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
4542                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
4543                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
4545                                 }
4546                         break;
4547
4548                         default:
4549                         break;
4550
4551                 }
4552         }
4553         return NDR_ERR_SUCCESS;
4554 }
4555
4556 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
4557 {
4558         int level;
4559         level = ndr_print_get_switch_value(ndr, r);
4560         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
4561         switch (level) {
4562                 case 0:
4563                         ndr_print_ptr(ndr, "info0", r->info0);
4564                         ndr->depth++;
4565                         if (r->info0) {
4566                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
4567                         }
4568                         ndr->depth--;
4569                 break;
4570
4571                 case 1:
4572                         ndr_print_ptr(ndr, "info1", r->info1);
4573                         ndr->depth++;
4574                         if (r->info1) {
4575                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
4576                         }
4577                         ndr->depth--;
4578                 break;
4579
4580                 case 2:
4581                         ndr_print_ptr(ndr, "info2", r->info2);
4582                         ndr->depth++;
4583                         if (r->info2) {
4584                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
4585                         }
4586                         ndr->depth--;
4587                 break;
4588
4589                 case 3:
4590                         ndr_print_ptr(ndr, "info3", r->info3);
4591                         ndr->depth++;
4592                         if (r->info3) {
4593                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
4594                         }
4595                         ndr->depth--;
4596                 break;
4597
4598                 case 4:
4599                         ndr_print_ptr(ndr, "info4", r->info4);
4600                         ndr->depth++;
4601                         if (r->info4) {
4602                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
4603                         }
4604                         ndr->depth--;
4605                 break;
4606
4607                 case 5:
4608                         ndr_print_ptr(ndr, "info5", r->info5);
4609                         ndr->depth++;
4610                         if (r->info5) {
4611                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
4612                         }
4613                         ndr->depth--;
4614                 break;
4615
4616                 case 6:
4617                         ndr_print_ptr(ndr, "info6", r->info6);
4618                         ndr->depth++;
4619                         if (r->info6) {
4620                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
4621                         }
4622                         ndr->depth--;
4623                 break;
4624
4625                 case 7:
4626                         ndr_print_ptr(ndr, "info7", r->info7);
4627                         ndr->depth++;
4628                         if (r->info7) {
4629                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
4630                         }
4631                         ndr->depth--;
4632                 break;
4633
4634                 case 8:
4635                         ndr_print_ptr(ndr, "info8", r->info8);
4636                         ndr->depth++;
4637                         if (r->info8) {
4638                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
4639                         }
4640                         ndr->depth--;
4641                 break;
4642
4643                 case 9:
4644                         ndr_print_ptr(ndr, "info9", r->info9);
4645                         ndr->depth++;
4646                         if (r->info9) {
4647                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
4648                         }
4649                         ndr->depth--;
4650                 break;
4651
4652                 default:
4653                 break;
4654
4655         }
4656 }
4657
4658 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
4659 {
4660         if (ndr_flags & NDR_SCALARS) {
4661                 NDR_CHECK(ndr_push_align(ndr, 4));
4662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
4664                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4665         }
4666         if (ndr_flags & NDR_BUFFERS) {
4667                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4668         }
4669         return NDR_ERR_SUCCESS;
4670 }
4671
4672 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
4673 {
4674         if (ndr_flags & NDR_SCALARS) {
4675                 NDR_CHECK(ndr_pull_align(ndr, 4));
4676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4677                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
4678                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4679         }
4680         if (ndr_flags & NDR_BUFFERS) {
4681                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4682         }
4683         return NDR_ERR_SUCCESS;
4684 }
4685
4686 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
4687 {
4688         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
4689         ndr->depth++;
4690         ndr_print_uint32(ndr, "level", r->level);
4691         ndr_print_set_switch_value(ndr, &r->info, r->level);
4692         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
4693         ndr->depth--;
4694 }
4695
4696 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
4697 {
4698         if (ndr_flags & NDR_SCALARS) {
4699                 NDR_CHECK(ndr_push_align(ndr, 4));
4700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
4701                 {
4702                         uint32_t _flags_save_string_array = ndr->flags;
4703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4704                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
4705                         ndr->flags = _flags_save_string_array;
4706                 }
4707         }
4708         if (ndr_flags & NDR_BUFFERS) {
4709         }
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
4714 {
4715         if (ndr_flags & NDR_SCALARS) {
4716                 NDR_CHECK(ndr_pull_align(ndr, 4));
4717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
4718                 {
4719                         uint32_t _flags_save_string_array = ndr->flags;
4720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4721                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
4722                         ndr->flags = _flags_save_string_array;
4723                 }
4724         }
4725         if (ndr_flags & NDR_BUFFERS) {
4726         }
4727         return NDR_ERR_SUCCESS;
4728 }
4729
4730 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
4731 {
4732         ndr_print_struct(ndr, name, "spoolss_StringArray");
4733         ndr->depth++;
4734         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
4735         ndr_print_string_array(ndr, "string", r->string);
4736         ndr->depth--;
4737 }
4738
4739 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
4740 {
4741         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
4742 }
4743
4744 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
4745 {
4746         if (ndr_flags & NDR_SCALARS) {
4747                 NDR_CHECK(ndr_push_align(ndr, 4));
4748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4749         }
4750         if (ndr_flags & NDR_BUFFERS) {
4751                 if (r->driver_name) {
4752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4756                 }
4757         }
4758         return NDR_ERR_SUCCESS;
4759 }
4760
4761 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
4762 {
4763         uint32_t _ptr_driver_name;
4764         TALLOC_CTX *_mem_save_driver_name_0;
4765         if (ndr_flags & NDR_SCALARS) {
4766                 NDR_CHECK(ndr_pull_align(ndr, 4));
4767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4768                 if (_ptr_driver_name) {
4769                         NDR_PULL_ALLOC(ndr, r->driver_name);
4770                 } else {
4771                         r->driver_name = NULL;
4772                 }
4773         }
4774         if (ndr_flags & NDR_BUFFERS) {
4775                 if (r->driver_name) {
4776                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4777                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4780                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4781                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4782                         }
4783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4786                 }
4787         }
4788         return NDR_ERR_SUCCESS;
4789 }
4790
4791 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
4792 {
4793         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
4794         ndr->depth++;
4795         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4796         ndr->depth++;
4797         if (r->driver_name) {
4798                 ndr_print_string(ndr, "driver_name", r->driver_name);
4799         }
4800         ndr->depth--;
4801         ndr->depth--;
4802 }
4803
4804 static enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
4805 {
4806         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4807         return NDR_ERR_SUCCESS;
4808 }
4809
4810 static enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
4811 {
4812         uint32_t v;
4813         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4814         *r = v;
4815         return NDR_ERR_SUCCESS;
4816 }
4817
4818 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
4819 {
4820         const char *val = NULL;
4821
4822         switch (r) {
4823                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
4824                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
4825                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
4826                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
4827         }
4828         ndr_print_enum(ndr, name, "ENUM", val, r);
4829 }
4830
4831 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
4832 {
4833         if (ndr_flags & NDR_SCALARS) {
4834                 NDR_CHECK(ndr_push_align(ndr, 4));
4835                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
4838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
4839                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
4840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
4841         }
4842         if (ndr_flags & NDR_BUFFERS) {
4843                 if (r->driver_name) {
4844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4848                 }
4849                 if (r->architecture) {
4850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4854                 }
4855                 if (r->driver_path) {
4856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4860                 }
4861                 if (r->data_file) {
4862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4866                 }
4867                 if (r->config_file) {
4868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4872                 }
4873         }
4874         return NDR_ERR_SUCCESS;
4875 }
4876
4877 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
4878 {
4879         uint32_t _ptr_driver_name;
4880         TALLOC_CTX *_mem_save_driver_name_0;
4881         uint32_t _ptr_architecture;
4882         TALLOC_CTX *_mem_save_architecture_0;
4883         uint32_t _ptr_driver_path;
4884         TALLOC_CTX *_mem_save_driver_path_0;
4885         uint32_t _ptr_data_file;
4886         TALLOC_CTX *_mem_save_data_file_0;
4887         uint32_t _ptr_config_file;
4888         TALLOC_CTX *_mem_save_config_file_0;
4889         if (ndr_flags & NDR_SCALARS) {
4890                 NDR_CHECK(ndr_pull_align(ndr, 4));
4891                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4893                 if (_ptr_driver_name) {
4894                         NDR_PULL_ALLOC(ndr, r->driver_name);
4895                 } else {
4896                         r->driver_name = NULL;
4897                 }
4898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4899                 if (_ptr_architecture) {
4900                         NDR_PULL_ALLOC(ndr, r->architecture);
4901                 } else {
4902                         r->architecture = NULL;
4903                 }
4904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4905                 if (_ptr_driver_path) {
4906                         NDR_PULL_ALLOC(ndr, r->driver_path);
4907                 } else {
4908                         r->driver_path = NULL;
4909                 }
4910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4911                 if (_ptr_data_file) {
4912                         NDR_PULL_ALLOC(ndr, r->data_file);
4913                 } else {
4914                         r->data_file = NULL;
4915                 }
4916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4917                 if (_ptr_config_file) {
4918                         NDR_PULL_ALLOC(ndr, r->config_file);
4919                 } else {
4920                         r->config_file = NULL;
4921                 }
4922         }
4923         if (ndr_flags & NDR_BUFFERS) {
4924                 if (r->driver_name) {
4925                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4926                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4929                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4930                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4931                         }
4932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4933                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4935                 }
4936                 if (r->architecture) {
4937                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4938                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
4940                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
4941                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
4942                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
4943                         }
4944                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
4945                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
4946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4947                 }
4948                 if (r->driver_path) {
4949                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4950                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4951                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
4952                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
4953                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
4954                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
4955                         }
4956                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
4957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
4958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4959                 }
4960                 if (r->data_file) {
4961                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4962                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
4964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
4965                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
4966                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
4967                         }
4968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
4969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
4970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4971                 }
4972                 if (r->config_file) {
4973                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4974                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
4976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
4977                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
4978                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
4979                         }
4980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
4981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
4982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4983                 }
4984         }
4985         return NDR_ERR_SUCCESS;
4986 }
4987
4988 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
4989 {
4990         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
4991         ndr->depth++;
4992         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4993         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4994         ndr->depth++;
4995         if (r->driver_name) {
4996                 ndr_print_string(ndr, "driver_name", r->driver_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "architecture", r->architecture);
5000         ndr->depth++;
5001         if (r->architecture) {
5002                 ndr_print_string(ndr, "architecture", r->architecture);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5006         ndr->depth++;
5007         if (r->driver_path) {
5008                 ndr_print_string(ndr, "driver_path", r->driver_path);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "data_file", r->data_file);
5012         ndr->depth++;
5013         if (r->data_file) {
5014                 ndr_print_string(ndr, "data_file", r->data_file);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "config_file", r->config_file);
5018         ndr->depth++;
5019         if (r->config_file) {
5020                 ndr_print_string(ndr, "config_file", r->config_file);
5021         }
5022         ndr->depth--;
5023         ndr->depth--;
5024 }
5025
5026 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
5027 {
5028         if (ndr_flags & NDR_SCALARS) {
5029                 NDR_CHECK(ndr_push_align(ndr, 4));
5030                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5041         }
5042         if (ndr_flags & NDR_BUFFERS) {
5043                 if (r->driver_name) {
5044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5047                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5048                 }
5049                 if (r->architecture) {
5050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5054                 }
5055                 if (r->driver_path) {
5056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5060                 }
5061                 if (r->data_file) {
5062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5066                 }
5067                 if (r->config_file) {
5068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5072                 }
5073                 if (r->help_file) {
5074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5078                 }
5079                 if (r->monitor_name) {
5080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5084                 }
5085                 if (r->default_datatype) {
5086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5090                 }
5091                 if (r->dependent_files) {
5092                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5093                 }
5094         }
5095         return NDR_ERR_SUCCESS;
5096 }
5097
5098 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
5099 {
5100         uint32_t _ptr_driver_name;
5101         TALLOC_CTX *_mem_save_driver_name_0;
5102         uint32_t _ptr_architecture;
5103         TALLOC_CTX *_mem_save_architecture_0;
5104         uint32_t _ptr_driver_path;
5105         TALLOC_CTX *_mem_save_driver_path_0;
5106         uint32_t _ptr_data_file;
5107         TALLOC_CTX *_mem_save_data_file_0;
5108         uint32_t _ptr_config_file;
5109         TALLOC_CTX *_mem_save_config_file_0;
5110         uint32_t _ptr_help_file;
5111         TALLOC_CTX *_mem_save_help_file_0;
5112         uint32_t _ptr_monitor_name;
5113         TALLOC_CTX *_mem_save_monitor_name_0;
5114         uint32_t _ptr_default_datatype;
5115         TALLOC_CTX *_mem_save_default_datatype_0;
5116         uint32_t _ptr_dependent_files;
5117         TALLOC_CTX *_mem_save_dependent_files_0;
5118         if (ndr_flags & NDR_SCALARS) {
5119                 NDR_CHECK(ndr_pull_align(ndr, 4));
5120                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5122                 if (_ptr_driver_name) {
5123                         NDR_PULL_ALLOC(ndr, r->driver_name);
5124                 } else {
5125                         r->driver_name = NULL;
5126                 }
5127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5128                 if (_ptr_architecture) {
5129                         NDR_PULL_ALLOC(ndr, r->architecture);
5130                 } else {
5131                         r->architecture = NULL;
5132                 }
5133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5134                 if (_ptr_driver_path) {
5135                         NDR_PULL_ALLOC(ndr, r->driver_path);
5136                 } else {
5137                         r->driver_path = NULL;
5138                 }
5139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5140                 if (_ptr_data_file) {
5141                         NDR_PULL_ALLOC(ndr, r->data_file);
5142                 } else {
5143                         r->data_file = NULL;
5144                 }
5145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5146                 if (_ptr_config_file) {
5147                         NDR_PULL_ALLOC(ndr, r->config_file);
5148                 } else {
5149                         r->config_file = NULL;
5150                 }
5151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5152                 if (_ptr_help_file) {
5153                         NDR_PULL_ALLOC(ndr, r->help_file);
5154                 } else {
5155                         r->help_file = NULL;
5156                 }
5157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5158                 if (_ptr_monitor_name) {
5159                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5160                 } else {
5161                         r->monitor_name = NULL;
5162                 }
5163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5164                 if (_ptr_default_datatype) {
5165                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5166                 } else {
5167                         r->default_datatype = NULL;
5168                 }
5169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5171                 if (_ptr_dependent_files) {
5172                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5173                 } else {
5174                         r->dependent_files = NULL;
5175                 }
5176         }
5177         if (ndr_flags & NDR_BUFFERS) {
5178                 if (r->driver_name) {
5179                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5180                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5183                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5185                         }
5186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5189                 }
5190                 if (r->architecture) {
5191                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5192                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5194                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5195                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5196                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5197                         }
5198                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5199                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5201                 }
5202                 if (r->driver_path) {
5203                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5204                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5205                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5206                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5207                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5208                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5209                         }
5210                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5211                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5213                 }
5214                 if (r->data_file) {
5215                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5216                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5218                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5219                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5220                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5221                         }
5222                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5223                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5225                 }
5226                 if (r->config_file) {
5227                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5228                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5229                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5230                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5231                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5232                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5233                         }
5234                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5235                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5236                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5237                 }
5238                 if (r->help_file) {
5239                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5240                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5241                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5242                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5243                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5244                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5245                         }
5246                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5247                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5249                 }
5250                 if (r->monitor_name) {
5251                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5252                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5255                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5256                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5257                         }
5258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5261                 }
5262                 if (r->default_datatype) {
5263                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5264                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5267                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5268                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5269                         }
5270                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5271                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5273                 }
5274                 if (r->dependent_files) {
5275                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5276                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5277                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5279                 }
5280         }
5281         return NDR_ERR_SUCCESS;
5282 }
5283
5284 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
5285 {
5286         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
5287         ndr->depth++;
5288         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5289         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5290         ndr->depth++;
5291         if (r->driver_name) {
5292                 ndr_print_string(ndr, "driver_name", r->driver_name);
5293         }
5294         ndr->depth--;
5295         ndr_print_ptr(ndr, "architecture", r->architecture);
5296         ndr->depth++;
5297         if (r->architecture) {
5298                 ndr_print_string(ndr, "architecture", r->architecture);
5299         }
5300         ndr->depth--;
5301         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5302         ndr->depth++;
5303         if (r->driver_path) {
5304                 ndr_print_string(ndr, "driver_path", r->driver_path);
5305         }
5306         ndr->depth--;
5307         ndr_print_ptr(ndr, "data_file", r->data_file);
5308         ndr->depth++;
5309         if (r->data_file) {
5310                 ndr_print_string(ndr, "data_file", r->data_file);
5311         }
5312         ndr->depth--;
5313         ndr_print_ptr(ndr, "config_file", r->config_file);
5314         ndr->depth++;
5315         if (r->config_file) {
5316                 ndr_print_string(ndr, "config_file", r->config_file);
5317         }
5318         ndr->depth--;
5319         ndr_print_ptr(ndr, "help_file", r->help_file);
5320         ndr->depth++;
5321         if (r->help_file) {
5322                 ndr_print_string(ndr, "help_file", r->help_file);
5323         }
5324         ndr->depth--;
5325         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5326         ndr->depth++;
5327         if (r->monitor_name) {
5328                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5329         }
5330         ndr->depth--;
5331         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5332         ndr->depth++;
5333         if (r->default_datatype) {
5334                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5335         }
5336         ndr->depth--;
5337         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
5338         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5339         ndr->depth++;
5340         if (r->dependent_files) {
5341                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5342         }
5343         ndr->depth--;
5344         ndr->depth--;
5345 }
5346
5347 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
5348 {
5349         if (ndr_flags & NDR_SCALARS) {
5350                 NDR_CHECK(ndr_push_align(ndr, 4));
5351                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5364         }
5365         if (ndr_flags & NDR_BUFFERS) {
5366                 if (r->driver_name) {
5367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5371                 }
5372                 if (r->architecture) {
5373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5377                 }
5378                 if (r->driver_path) {
5379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5383                 }
5384                 if (r->data_file) {
5385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5388                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5389                 }
5390                 if (r->config_file) {
5391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5395                 }
5396                 if (r->help_file) {
5397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5401                 }
5402                 if (r->monitor_name) {
5403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5407                 }
5408                 if (r->default_datatype) {
5409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5413                 }
5414                 if (r->dependent_files) {
5415                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5416                 }
5417                 if (r->previous_names) {
5418                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5419                 }
5420         }
5421         return NDR_ERR_SUCCESS;
5422 }
5423
5424 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
5425 {
5426         uint32_t _ptr_driver_name;
5427         TALLOC_CTX *_mem_save_driver_name_0;
5428         uint32_t _ptr_architecture;
5429         TALLOC_CTX *_mem_save_architecture_0;
5430         uint32_t _ptr_driver_path;
5431         TALLOC_CTX *_mem_save_driver_path_0;
5432         uint32_t _ptr_data_file;
5433         TALLOC_CTX *_mem_save_data_file_0;
5434         uint32_t _ptr_config_file;
5435         TALLOC_CTX *_mem_save_config_file_0;
5436         uint32_t _ptr_help_file;
5437         TALLOC_CTX *_mem_save_help_file_0;
5438         uint32_t _ptr_monitor_name;
5439         TALLOC_CTX *_mem_save_monitor_name_0;
5440         uint32_t _ptr_default_datatype;
5441         TALLOC_CTX *_mem_save_default_datatype_0;
5442         uint32_t _ptr_dependent_files;
5443         TALLOC_CTX *_mem_save_dependent_files_0;
5444         uint32_t _ptr_previous_names;
5445         TALLOC_CTX *_mem_save_previous_names_0;
5446         if (ndr_flags & NDR_SCALARS) {
5447                 NDR_CHECK(ndr_pull_align(ndr, 4));
5448                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5449                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5450                 if (_ptr_driver_name) {
5451                         NDR_PULL_ALLOC(ndr, r->driver_name);
5452                 } else {
5453                         r->driver_name = NULL;
5454                 }
5455                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5456                 if (_ptr_architecture) {
5457                         NDR_PULL_ALLOC(ndr, r->architecture);
5458                 } else {
5459                         r->architecture = NULL;
5460                 }
5461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5462                 if (_ptr_driver_path) {
5463                         NDR_PULL_ALLOC(ndr, r->driver_path);
5464                 } else {
5465                         r->driver_path = NULL;
5466                 }
5467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5468                 if (_ptr_data_file) {
5469                         NDR_PULL_ALLOC(ndr, r->data_file);
5470                 } else {
5471                         r->data_file = NULL;
5472                 }
5473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5474                 if (_ptr_config_file) {
5475                         NDR_PULL_ALLOC(ndr, r->config_file);
5476                 } else {
5477                         r->config_file = NULL;
5478                 }
5479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5480                 if (_ptr_help_file) {
5481                         NDR_PULL_ALLOC(ndr, r->help_file);
5482                 } else {
5483                         r->help_file = NULL;
5484                 }
5485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5486                 if (_ptr_monitor_name) {
5487                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5488                 } else {
5489                         r->monitor_name = NULL;
5490                 }
5491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5492                 if (_ptr_default_datatype) {
5493                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5494                 } else {
5495                         r->default_datatype = NULL;
5496                 }
5497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5499                 if (_ptr_dependent_files) {
5500                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5501                 } else {
5502                         r->dependent_files = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5506                 if (_ptr_previous_names) {
5507                         NDR_PULL_ALLOC(ndr, r->previous_names);
5508                 } else {
5509                         r->previous_names = NULL;
5510                 }
5511         }
5512         if (ndr_flags & NDR_BUFFERS) {
5513                 if (r->driver_name) {
5514                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5515                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5516                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5517                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5518                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5519                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5520                         }
5521                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5524                 }
5525                 if (r->architecture) {
5526                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5527                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5530                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5531                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5532                         }
5533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5536                 }
5537                 if (r->driver_path) {
5538                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5539                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5542                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5543                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5544                         }
5545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5548                 }
5549                 if (r->data_file) {
5550                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5551                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5554                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5555                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5556                         }
5557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5560                 }
5561                 if (r->config_file) {
5562                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5563                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5566                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5568                         }
5569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5572                 }
5573                 if (r->help_file) {
5574                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5575                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5576                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5577                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5578                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5579                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5580                         }
5581                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5582                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5584                 }
5585                 if (r->monitor_name) {
5586                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5587                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5588                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5589                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5590                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5591                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5592                         }
5593                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5594                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5596                 }
5597                 if (r->default_datatype) {
5598                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5599                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5600                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5601                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5602                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5603                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5604                         }
5605                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5606                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5608                 }
5609                 if (r->dependent_files) {
5610                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5611                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5612                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5614                 }
5615                 if (r->previous_names) {
5616                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5617                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
5618                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
5620                 }
5621         }
5622         return NDR_ERR_SUCCESS;
5623 }
5624
5625 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
5626 {
5627         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
5628         ndr->depth++;
5629         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5630         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5631         ndr->depth++;
5632         if (r->driver_name) {
5633                 ndr_print_string(ndr, "driver_name", r->driver_name);
5634         }
5635         ndr->depth--;
5636         ndr_print_ptr(ndr, "architecture", r->architecture);
5637         ndr->depth++;
5638         if (r->architecture) {
5639                 ndr_print_string(ndr, "architecture", r->architecture);
5640         }
5641         ndr->depth--;
5642         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5643         ndr->depth++;
5644         if (r->driver_path) {
5645                 ndr_print_string(ndr, "driver_path", r->driver_path);
5646         }
5647         ndr->depth--;
5648         ndr_print_ptr(ndr, "data_file", r->data_file);
5649         ndr->depth++;
5650         if (r->data_file) {
5651                 ndr_print_string(ndr, "data_file", r->data_file);
5652         }
5653         ndr->depth--;
5654         ndr_print_ptr(ndr, "config_file", r->config_file);
5655         ndr->depth++;
5656         if (r->config_file) {
5657                 ndr_print_string(ndr, "config_file", r->config_file);
5658         }
5659         ndr->depth--;
5660         ndr_print_ptr(ndr, "help_file", r->help_file);
5661         ndr->depth++;
5662         if (r->help_file) {
5663                 ndr_print_string(ndr, "help_file", r->help_file);
5664         }
5665         ndr->depth--;
5666         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5667         ndr->depth++;
5668         if (r->monitor_name) {
5669                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5670         }
5671         ndr->depth--;
5672         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5673         ndr->depth++;
5674         if (r->default_datatype) {
5675                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5676         }
5677         ndr->depth--;
5678         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
5679         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5680         ndr->depth++;
5681         if (r->dependent_files) {
5682                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5683         }
5684         ndr->depth--;
5685         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
5686         ndr_print_ptr(ndr, "previous_names", r->previous_names);
5687         ndr->depth++;
5688         if (r->previous_names) {
5689                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
5690         }
5691         ndr->depth--;
5692         ndr->depth--;
5693 }
5694
5695 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
5696 {
5697         if (ndr_flags & NDR_SCALARS) {
5698                 NDR_CHECK(ndr_push_align(ndr, 8));
5699                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5712                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
5713                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
5714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
5715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
5716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
5717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
5718         }
5719         if (ndr_flags & NDR_BUFFERS) {
5720                 if (r->driver_name) {
5721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5725                 }
5726                 if (r->architecture) {
5727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5731                 }
5732                 if (r->driver_path) {
5733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5737                 }
5738                 if (r->data_file) {
5739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5743                 }
5744                 if (r->config_file) {
5745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5749                 }
5750                 if (r->help_file) {
5751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5755                 }
5756                 if (r->monitor_name) {
5757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5761                 }
5762                 if (r->default_datatype) {
5763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5766                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5767                 }
5768                 if (r->dependent_files) {
5769                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5770                 }
5771                 if (r->previous_names) {
5772                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5773                 }
5774                 if (r->manufacturer_name) {
5775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5778                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5779                 }
5780                 if (r->manufacturer_url) {
5781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5784                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5785                 }
5786                 if (r->hardware_id) {
5787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5790                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5791                 }
5792                 if (r->provider) {
5793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5796                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5797                 }
5798         }
5799         return NDR_ERR_SUCCESS;
5800 }
5801
5802 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
5803 {
5804         uint32_t _ptr_driver_name;
5805         TALLOC_CTX *_mem_save_driver_name_0;
5806         uint32_t _ptr_architecture;
5807         TALLOC_CTX *_mem_save_architecture_0;
5808         uint32_t _ptr_driver_path;
5809         TALLOC_CTX *_mem_save_driver_path_0;
5810         uint32_t _ptr_data_file;
5811         TALLOC_CTX *_mem_save_data_file_0;
5812         uint32_t _ptr_config_file;
5813         TALLOC_CTX *_mem_save_config_file_0;
5814         uint32_t _ptr_help_file;
5815         TALLOC_CTX *_mem_save_help_file_0;
5816         uint32_t _ptr_monitor_name;
5817         TALLOC_CTX *_mem_save_monitor_name_0;
5818         uint32_t _ptr_default_datatype;
5819         TALLOC_CTX *_mem_save_default_datatype_0;
5820         uint32_t _ptr_dependent_files;
5821         TALLOC_CTX *_mem_save_dependent_files_0;
5822         uint32_t _ptr_previous_names;
5823         TALLOC_CTX *_mem_save_previous_names_0;
5824         uint32_t _ptr_manufacturer_name;
5825         TALLOC_CTX *_mem_save_manufacturer_name_0;
5826         uint32_t _ptr_manufacturer_url;
5827         TALLOC_CTX *_mem_save_manufacturer_url_0;
5828         uint32_t _ptr_hardware_id;
5829         TALLOC_CTX *_mem_save_hardware_id_0;
5830         uint32_t _ptr_provider;
5831         TALLOC_CTX *_mem_save_provider_0;
5832         if (ndr_flags & NDR_SCALARS) {
5833                 NDR_CHECK(ndr_pull_align(ndr, 8));
5834                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5836                 if (_ptr_driver_name) {
5837                         NDR_PULL_ALLOC(ndr, r->driver_name);
5838                 } else {
5839                         r->driver_name = NULL;
5840                 }
5841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5842                 if (_ptr_architecture) {
5843                         NDR_PULL_ALLOC(ndr, r->architecture);
5844                 } else {
5845                         r->architecture = NULL;
5846                 }
5847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5848                 if (_ptr_driver_path) {
5849                         NDR_PULL_ALLOC(ndr, r->driver_path);
5850                 } else {
5851                         r->driver_path = NULL;
5852                 }
5853                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5854                 if (_ptr_data_file) {
5855                         NDR_PULL_ALLOC(ndr, r->data_file);
5856                 } else {
5857                         r->data_file = NULL;
5858                 }
5859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5860                 if (_ptr_config_file) {
5861                         NDR_PULL_ALLOC(ndr, r->config_file);
5862                 } else {
5863                         r->config_file = NULL;
5864                 }
5865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5866                 if (_ptr_help_file) {
5867                         NDR_PULL_ALLOC(ndr, r->help_file);
5868                 } else {
5869                         r->help_file = NULL;
5870                 }
5871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5872                 if (_ptr_monitor_name) {
5873                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5874                 } else {
5875                         r->monitor_name = NULL;
5876                 }
5877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5878                 if (_ptr_default_datatype) {
5879                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5880                 } else {
5881                         r->default_datatype = NULL;
5882                 }
5883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5885                 if (_ptr_dependent_files) {
5886                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5887                 } else {
5888                         r->dependent_files = NULL;
5889                 }
5890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5892                 if (_ptr_previous_names) {
5893                         NDR_PULL_ALLOC(ndr, r->previous_names);
5894                 } else {
5895                         r->previous_names = NULL;
5896                 }
5897                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
5898                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
5899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
5900                 if (_ptr_manufacturer_name) {
5901                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
5902                 } else {
5903                         r->manufacturer_name = NULL;
5904                 }
5905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
5906                 if (_ptr_manufacturer_url) {
5907                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
5908                 } else {
5909                         r->manufacturer_url = NULL;
5910                 }
5911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
5912                 if (_ptr_hardware_id) {
5913                         NDR_PULL_ALLOC(ndr, r->hardware_id);
5914                 } else {
5915                         r->hardware_id = NULL;
5916                 }
5917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
5918                 if (_ptr_provider) {
5919                         NDR_PULL_ALLOC(ndr, r->provider);
5920                 } else {
5921                         r->provider = NULL;
5922                 }
5923         }
5924         if (ndr_flags & NDR_BUFFERS) {
5925                 if (r->driver_name) {
5926                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5927                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5930                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5931                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5932                         }
5933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5936                 }
5937                 if (r->architecture) {
5938                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5939                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5942                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5943                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5944                         }
5945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5948                 }
5949                 if (r->driver_path) {
5950                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5951                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5954                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5955                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5956                         }
5957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5960                 }
5961                 if (r->data_file) {
5962                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5963                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5966                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5967                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5968                         }
5969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5972                 }
5973                 if (r->config_file) {
5974                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5975                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5977                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5978                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5979                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5980                         }
5981                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5982                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5984                 }
5985                 if (r->help_file) {
5986                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5987                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5990                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5991                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5992                         }
5993                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5994                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5996                 }
5997                 if (r->monitor_name) {
5998                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5999                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6002                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6003                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
6004                         }
6005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6008                 }
6009                 if (r->default_datatype) {
6010                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6011                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6014                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
6016                         }
6017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6020                 }
6021                 if (r->dependent_files) {
6022                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6023                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6024                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6026                 }
6027                 if (r->previous_names) {
6028                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6030                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6032                 }
6033                 if (r->manufacturer_name) {
6034                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6038                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6039                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
6040                         }
6041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6044                 }
6045                 if (r->manufacturer_url) {
6046                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6047                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6050                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6051                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
6052                         }
6053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6056                 }
6057                 if (r->hardware_id) {
6058                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6059                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6062                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
6064                         }
6065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6068                 }
6069                 if (r->provider) {
6070                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6071                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6074                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6075                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
6076                         }
6077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6080                 }
6081         }
6082         return NDR_ERR_SUCCESS;
6083 }
6084
6085 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
6086 {
6087         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
6088         ndr->depth++;
6089         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6090         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6091         ndr->depth++;
6092         if (r->driver_name) {
6093                 ndr_print_string(ndr, "driver_name", r->driver_name);
6094         }
6095         ndr->depth--;
6096         ndr_print_ptr(ndr, "architecture", r->architecture);
6097         ndr->depth++;
6098         if (r->architecture) {
6099                 ndr_print_string(ndr, "architecture", r->architecture);
6100         }
6101         ndr->depth--;
6102         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6103         ndr->depth++;
6104         if (r->driver_path) {
6105                 ndr_print_string(ndr, "driver_path", r->driver_path);
6106         }
6107         ndr->depth--;
6108         ndr_print_ptr(ndr, "data_file", r->data_file);
6109         ndr->depth++;
6110         if (r->data_file) {
6111                 ndr_print_string(ndr, "data_file", r->data_file);
6112         }
6113         ndr->depth--;
6114         ndr_print_ptr(ndr, "config_file", r->config_file);
6115         ndr->depth++;
6116         if (r->config_file) {
6117                 ndr_print_string(ndr, "config_file", r->config_file);
6118         }
6119         ndr->depth--;
6120         ndr_print_ptr(ndr, "help_file", r->help_file);
6121         ndr->depth++;
6122         if (r->help_file) {
6123                 ndr_print_string(ndr, "help_file", r->help_file);
6124         }
6125         ndr->depth--;
6126         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6127         ndr->depth++;
6128         if (r->monitor_name) {
6129                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6130         }
6131         ndr->depth--;
6132         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6133         ndr->depth++;
6134         if (r->default_datatype) {
6135                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6136         }
6137         ndr->depth--;
6138         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
6139         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6140         ndr->depth++;
6141         if (r->dependent_files) {
6142                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6143         }
6144         ndr->depth--;
6145         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
6146         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6147         ndr->depth++;
6148         if (r->previous_names) {
6149                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6150         }
6151         ndr->depth--;
6152         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6153         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6154         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6155         ndr->depth++;
6156         if (r->manufacturer_name) {
6157                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6158         }
6159         ndr->depth--;
6160         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6161         ndr->depth++;
6162         if (r->manufacturer_url) {
6163                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6164         }
6165         ndr->depth--;
6166         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6167         ndr->depth++;
6168         if (r->hardware_id) {
6169                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6170         }
6171         ndr->depth--;
6172         ndr_print_ptr(ndr, "provider", r->provider);
6173         ndr->depth++;
6174         if (r->provider) {
6175                 ndr_print_string(ndr, "provider", r->provider);
6176         }
6177         ndr->depth--;
6178         ndr->depth--;
6179 }
6180
6181 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
6182 {
6183         if (ndr_flags & NDR_SCALARS) {
6184                 int level = ndr_push_get_switch_value(ndr, r);
6185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6186                 switch (level) {
6187                         case 1: {
6188                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6189                         break; }
6190
6191                         case 2: {
6192                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6193                         break; }
6194
6195                         case 3: {
6196                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6197                         break; }
6198
6199                         case 4: {
6200                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6201                         break; }
6202
6203                         case 6: {
6204                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6205                         break; }
6206
6207                         default:
6208                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6209                 }
6210         }
6211         if (ndr_flags & NDR_BUFFERS) {
6212                 int level = ndr_push_get_switch_value(ndr, r);
6213                 switch (level) {
6214                         case 1:
6215                                 if (r->info1) {
6216                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6217                                 }
6218                         break;
6219
6220                         case 2:
6221                                 if (r->info2) {
6222                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6223                                 }
6224                         break;
6225
6226                         case 3:
6227                                 if (r->info3) {
6228                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6229                                 }
6230                         break;
6231
6232                         case 4:
6233                                 if (r->info4) {
6234                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6235                                 }
6236                         break;
6237
6238                         case 6:
6239                                 if (r->info6) {
6240                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
6241                                 }
6242                         break;
6243
6244                         default:
6245                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6246                 }
6247         }
6248         return NDR_ERR_SUCCESS;
6249 }
6250
6251 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
6252 {
6253         int level;
6254         uint32_t _level;
6255         TALLOC_CTX *_mem_save_info1_0;
6256         TALLOC_CTX *_mem_save_info2_0;
6257         TALLOC_CTX *_mem_save_info3_0;
6258         TALLOC_CTX *_mem_save_info4_0;
6259         TALLOC_CTX *_mem_save_info6_0;
6260         level = ndr_pull_get_switch_value(ndr, r);
6261         if (ndr_flags & NDR_SCALARS) {
6262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6263                 if (_level != level) {
6264                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6265                 }
6266                 switch (level) {
6267                         case 1: {
6268                                 uint32_t _ptr_info1;
6269                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6270                                 if (_ptr_info1) {
6271                                         NDR_PULL_ALLOC(ndr, r->info1);
6272                                 } else {
6273                                         r->info1 = NULL;
6274                                 }
6275                         break; }
6276
6277                         case 2: {
6278                                 uint32_t _ptr_info2;
6279                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6280                                 if (_ptr_info2) {
6281                                         NDR_PULL_ALLOC(ndr, r->info2);
6282                                 } else {
6283                                         r->info2 = NULL;
6284                                 }
6285                         break; }
6286
6287                         case 3: {
6288                                 uint32_t _ptr_info3;
6289                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6290                                 if (_ptr_info3) {
6291                                         NDR_PULL_ALLOC(ndr, r->info3);
6292                                 } else {
6293                                         r->info3 = NULL;
6294                                 }
6295                         break; }
6296
6297                         case 4: {
6298                                 uint32_t _ptr_info4;
6299                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6300                                 if (_ptr_info4) {
6301                                         NDR_PULL_ALLOC(ndr, r->info4);
6302                                 } else {
6303                                         r->info4 = NULL;
6304                                 }
6305                         break; }
6306
6307                         case 6: {
6308                                 uint32_t _ptr_info6;
6309                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
6310                                 if (_ptr_info6) {
6311                                         NDR_PULL_ALLOC(ndr, r->info6);
6312                                 } else {
6313                                         r->info6 = NULL;
6314                                 }
6315                         break; }
6316
6317                         default:
6318                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6319                 }
6320         }
6321         if (ndr_flags & NDR_BUFFERS) {
6322                 switch (level) {
6323                         case 1:
6324                                 if (r->info1) {
6325                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6326                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6327                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6328                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6329                                 }
6330                         break;
6331
6332                         case 2:
6333                                 if (r->info2) {
6334                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6335                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6336                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6338                                 }
6339                         break;
6340
6341                         case 3:
6342                                 if (r->info3) {
6343                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6344                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6345                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6346                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6347                                 }
6348                         break;
6349
6350                         case 4:
6351                                 if (r->info4) {
6352                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6353                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6354                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6355                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6356                                 }
6357                         break;
6358
6359                         case 6:
6360                                 if (r->info6) {
6361                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
6362                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
6363                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
6364                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
6365                                 }
6366                         break;
6367
6368                         default:
6369                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6370                 }
6371         }
6372         return NDR_ERR_SUCCESS;
6373 }
6374
6375 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
6376 {
6377         int level;
6378         level = ndr_print_get_switch_value(ndr, r);
6379         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
6380         switch (level) {
6381                 case 1:
6382                         ndr_print_ptr(ndr, "info1", r->info1);
6383                         ndr->depth++;
6384                         if (r->info1) {
6385                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
6386                         }
6387                         ndr->depth--;
6388                 break;
6389
6390                 case 2:
6391                         ndr_print_ptr(ndr, "info2", r->info2);
6392                         ndr->depth++;
6393                         if (r->info2) {
6394                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
6395                         }
6396                         ndr->depth--;
6397                 break;
6398
6399                 case 3:
6400                         ndr_print_ptr(ndr, "info3", r->info3);
6401                         ndr->depth++;
6402                         if (r->info3) {
6403                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
6404                         }
6405                         ndr->depth--;
6406                 break;
6407
6408                 case 4:
6409                         ndr_print_ptr(ndr, "info4", r->info4);
6410                         ndr->depth++;
6411                         if (r->info4) {
6412                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
6413                         }
6414                         ndr->depth--;
6415                 break;
6416
6417                 case 6:
6418                         ndr_print_ptr(ndr, "info6", r->info6);
6419                         ndr->depth++;
6420                         if (r->info6) {
6421                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
6422                         }
6423                         ndr->depth--;
6424                 break;
6425
6426                 default:
6427                         ndr_print_bad_level(ndr, name, level);
6428         }
6429 }
6430
6431 static enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
6432 {
6433         if (ndr_flags & NDR_SCALARS) {
6434                 NDR_CHECK(ndr_push_align(ndr, 4));
6435                 {
6436                         uint32_t _flags_save_string = ndr->flags;
6437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6438                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
6439                         ndr->flags = _flags_save_string;
6440                 }
6441         }
6442         if (ndr_flags & NDR_BUFFERS) {
6443                 {
6444                         uint32_t _flags_save_string = ndr->flags;
6445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6446                         if (r->driver_name) {
6447                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
6448                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
6449                         }
6450                         ndr->flags = _flags_save_string;
6451                 }
6452         }
6453         return NDR_ERR_SUCCESS;
6454 }
6455
6456 static enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
6457 {
6458         uint32_t _ptr_driver_name;
6459         TALLOC_CTX *_mem_save_driver_name_0;
6460         if (ndr_flags & NDR_SCALARS) {
6461                 NDR_CHECK(ndr_pull_align(ndr, 4));
6462                 {
6463                         uint32_t _flags_save_string = ndr->flags;
6464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6465                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6466                         if (_ptr_driver_name) {
6467                                 NDR_PULL_ALLOC(ndr, r->driver_name);
6468                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
6469                         } else {
6470                                 r->driver_name = NULL;
6471                         }
6472                         ndr->flags = _flags_save_string;
6473                 }
6474         }
6475         if (ndr_flags & NDR_BUFFERS) {
6476                 {
6477                         uint32_t _flags_save_string = ndr->flags;
6478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6479                         if (r->driver_name) {
6480                                 uint32_t _relative_save_offset;
6481                                 _relative_save_offset = ndr->offset;
6482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
6483                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6484                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
6486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6487                                 ndr->offset = _relative_save_offset;
6488                         }
6489                         ndr->flags = _flags_save_string;
6490                 }
6491         }
6492         return NDR_ERR_SUCCESS;
6493 }
6494
6495 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
6496 {
6497         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
6498         ndr->depth++;
6499         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6500         ndr->depth++;
6501         if (r->driver_name) {
6502                 ndr_print_string(ndr, "driver_name", r->driver_name);
6503         }
6504         ndr->depth--;
6505         ndr->depth--;
6506 }
6507
6508 static enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
6509 {
6510         if (ndr_flags & NDR_SCALARS) {
6511                 NDR_CHECK(ndr_push_align(ndr, 4));
6512                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6513                 {
6514                         uint32_t _flags_save_string = ndr->flags;
6515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6516                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
6517                         ndr->flags = _flags_save_string;
6518                 }
6519                 {
6520                         uint32_t _flags_save_string = ndr->flags;
6521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6522                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
6523                         ndr->flags = _flags_save_string;
6524                 }
6525                 {
6526                         uint32_t _flags_save_string = ndr->flags;
6527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6528                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
6529                         ndr->flags = _flags_save_string;
6530                 }
6531                 {
6532                         uint32_t _flags_save_string = ndr->flags;
6533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6534                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
6535                         ndr->flags = _flags_save_string;
6536                 }
6537                 {
6538                         uint32_t _flags_save_string = ndr->flags;
6539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6540                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
6541                         ndr->flags = _flags_save_string;
6542                 }
6543         }
6544         if (ndr_flags & NDR_BUFFERS) {
6545                 {
6546                         uint32_t _flags_save_string = ndr->flags;
6547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6548                         if (r->driver_name) {
6549                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
6550                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
6551                         }
6552                         ndr->flags = _flags_save_string;
6553                 }
6554                 {
6555                         uint32_t _flags_save_string = ndr->flags;
6556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6557                         if (r->architecture) {
6558                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
6559                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
6560                         }
6561                         ndr->flags = _flags_save_string;
6562                 }
6563                 {
6564                         uint32_t _flags_save_string = ndr->flags;
6565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6566                         if (r->driver_path) {
6567                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
6568                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
6569                         }
6570                         ndr->flags = _flags_save_string;
6571                 }
6572                 {
6573                         uint32_t _flags_save_string = ndr->flags;
6574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6575                         if (r->data_file) {
6576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
6577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
6578                         }
6579                         ndr->flags = _flags_save_string;
6580                 }
6581                 {
6582                         uint32_t _flags_save_string = ndr->flags;
6583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6584                         if (r->config_file) {
6585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
6586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
6587                         }
6588                         ndr->flags = _flags_save_string;
6589                 }
6590         }
6591         return NDR_ERR_SUCCESS;
6592 }
6593
6594 static enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
6595 {
6596         uint32_t _ptr_driver_name;
6597         TALLOC_CTX *_mem_save_driver_name_0;
6598         uint32_t _ptr_architecture;
6599         TALLOC_CTX *_mem_save_architecture_0;
6600         uint32_t _ptr_driver_path;
6601         TALLOC_CTX *_mem_save_driver_path_0;
6602         uint32_t _ptr_data_file;
6603         TALLOC_CTX *_mem_save_data_file_0;
6604         uint32_t _ptr_config_file;
6605         TALLOC_CTX *_mem_save_config_file_0;
6606         if (ndr_flags & NDR_SCALARS) {
6607                 NDR_CHECK(ndr_pull_align(ndr, 4));
6608                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6609                 {
6610                         uint32_t _flags_save_string = ndr->flags;
6611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6612                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6613                         if (_ptr_driver_name) {
6614                                 NDR_PULL_ALLOC(ndr, r->driver_name);
6615                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
6616                         } else {
6617                                 r->driver_name = NULL;
6618                         }
6619                         ndr->flags = _flags_save_string;
6620                 }
6621                 {
6622                         uint32_t _flags_save_string = ndr->flags;
6623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6624                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6625                         if (_ptr_architecture) {
6626                                 NDR_PULL_ALLOC(ndr, r->architecture);
6627                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
6628                         } else {
6629                                 r->architecture = NULL;
6630                         }
6631                         ndr->flags = _flags_save_string;
6632                 }
6633                 {
6634                         uint32_t _flags_save_string = ndr->flags;
6635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6636                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6637                         if (_ptr_driver_path) {
6638                                 NDR_PULL_ALLOC(ndr, r->driver_path);
6639                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
6640                         } else {
6641                                 r->driver_path = NULL;
6642                         }
6643                         ndr->flags = _flags_save_string;
6644                 }
6645                 {
6646                         uint32_t _flags_save_string = ndr->flags;
6647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6648                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6649                         if (_ptr_data_file) {
6650                                 NDR_PULL_ALLOC(ndr, r->data_file);
6651                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
6652                         } else {
6653                                 r->data_file = NULL;
6654                         }
6655                         ndr->flags = _flags_save_string;
6656                 }
6657                 {
6658                         uint32_t _flags_save_string = ndr->flags;
6659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6660                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6661                         if (_ptr_config_file) {
6662                                 NDR_PULL_ALLOC(ndr, r->config_file);
6663                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
6664                         } else {
6665                                 r->config_file = NULL;
6666                         }
6667                         ndr->flags = _flags_save_string;
6668                 }
6669         }
6670         if (ndr_flags & NDR_BUFFERS) {
6671                 {
6672                         uint32_t _flags_save_string = ndr->flags;
6673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6674                         if (r->driver_name) {
6675                                 uint32_t _relative_save_offset;
6676                                 _relative_save_offset = ndr->offset;
6677                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
6678                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6679                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6680                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
6681                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6682                                 ndr->offset = _relative_save_offset;
6683                         }
6684                         ndr->flags = _flags_save_string;
6685                 }
6686                 {
6687                         uint32_t _flags_save_string = ndr->flags;
6688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6689                         if (r->architecture) {
6690                                 uint32_t _relative_save_offset;
6691                                 _relative_save_offset = ndr->offset;
6692                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
6693                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6694                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6695                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
6696                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6697                                 ndr->offset = _relative_save_offset;
6698                         }
6699                         ndr->flags = _flags_save_string;
6700                 }
6701                 {
6702                         uint32_t _flags_save_string = ndr->flags;
6703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6704                         if (r->driver_path) {
6705                                 uint32_t _relative_save_offset;
6706                                 _relative_save_offset = ndr->offset;
6707                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
6708                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6709                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6710                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
6711                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6712                                 ndr->offset = _relative_save_offset;
6713                         }
6714                         ndr->flags = _flags_save_string;
6715                 }
6716                 {
6717                         uint32_t _flags_save_string = ndr->flags;
6718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6719                         if (r->data_file) {
6720                                 uint32_t _relative_save_offset;
6721                                 _relative_save_offset = ndr->offset;
6722                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
6723                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6724                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6725                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
6726                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6727                                 ndr->offset = _relative_save_offset;
6728                         }
6729                         ndr->flags = _flags_save_string;
6730                 }
6731                 {
6732                         uint32_t _flags_save_string = ndr->flags;
6733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6734                         if (r->config_file) {
6735                                 uint32_t _relative_save_offset;
6736                                 _relative_save_offset = ndr->offset;
6737                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
6738                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6739                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6740                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
6741                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6742                                 ndr->offset = _relative_save_offset;
6743                         }
6744                         ndr->flags = _flags_save_string;
6745                 }
6746         }
6747         return NDR_ERR_SUCCESS;
6748 }
6749
6750 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
6751 {
6752         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
6753         ndr->depth++;
6754         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6755         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6756         ndr->depth++;
6757         if (r->driver_name) {
6758                 ndr_print_string(ndr, "driver_name", r->driver_name);
6759         }
6760         ndr->depth--;
6761         ndr_print_ptr(ndr, "architecture", r->architecture);
6762         ndr->depth++;
6763         if (r->architecture) {
6764                 ndr_print_string(ndr, "architecture", r->architecture);
6765         }
6766         ndr->depth--;
6767         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6768         ndr->depth++;
6769         if (r->driver_path) {
6770                 ndr_print_string(ndr, "driver_path", r->driver_path);
6771         }
6772         ndr->depth--;
6773         ndr_print_ptr(ndr, "data_file", r->data_file);
6774         ndr->depth++;
6775         if (r->data_file) {
6776                 ndr_print_string(ndr, "data_file", r->data_file);
6777         }
6778         ndr->depth--;
6779         ndr_print_ptr(ndr, "config_file", r->config_file);
6780         ndr->depth++;
6781         if (r->config_file) {
6782                 ndr_print_string(ndr, "config_file", r->config_file);
6783         }
6784         ndr->depth--;
6785         ndr->depth--;
6786 }
6787
6788 static enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
6789 {
6790         if (ndr_flags & NDR_SCALARS) {
6791                 NDR_CHECK(ndr_push_align(ndr, 4));
6792                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6793                 {
6794                         uint32_t _flags_save_string = ndr->flags;
6795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6796                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
6797                         ndr->flags = _flags_save_string;
6798                 }
6799                 {
6800                         uint32_t _flags_save_string = ndr->flags;
6801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6802                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
6803                         ndr->flags = _flags_save_string;
6804                 }
6805                 {
6806                         uint32_t _flags_save_string = ndr->flags;
6807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6808                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
6809                         ndr->flags = _flags_save_string;
6810                 }
6811                 {
6812                         uint32_t _flags_save_string = ndr->flags;
6813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6814                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
6815                         ndr->flags = _flags_save_string;
6816                 }
6817                 {
6818                         uint32_t _flags_save_string = ndr->flags;
6819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6820                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
6821                         ndr->flags = _flags_save_string;
6822                 }
6823                 {
6824                         uint32_t _flags_save_string = ndr->flags;
6825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6826                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
6827                         ndr->flags = _flags_save_string;
6828                 }
6829                 {
6830                         uint32_t _flags_save_string_array = ndr->flags;
6831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6832                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
6833                         ndr->flags = _flags_save_string_array;
6834                 }
6835                 {
6836                         uint32_t _flags_save_string = ndr->flags;
6837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6838                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
6839                         ndr->flags = _flags_save_string;
6840                 }
6841                 {
6842                         uint32_t _flags_save_string = ndr->flags;
6843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6844                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
6845                         ndr->flags = _flags_save_string;
6846                 }
6847         }
6848         if (ndr_flags & NDR_BUFFERS) {
6849                 {
6850                         uint32_t _flags_save_string = ndr->flags;
6851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6852                         if (r->driver_name) {
6853                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
6854                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
6855                         }
6856                         ndr->flags = _flags_save_string;
6857                 }
6858                 {
6859                         uint32_t _flags_save_string = ndr->flags;
6860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6861                         if (r->architecture) {
6862                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
6863                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
6864                         }
6865                         ndr->flags = _flags_save_string;
6866                 }
6867                 {
6868                         uint32_t _flags_save_string = ndr->flags;
6869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6870                         if (r->driver_path) {
6871                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
6872                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
6873                         }
6874                         ndr->flags = _flags_save_string;
6875                 }
6876                 {
6877                         uint32_t _flags_save_string = ndr->flags;
6878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6879                         if (r->data_file) {
6880                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
6881                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
6882                         }
6883                         ndr->flags = _flags_save_string;
6884                 }
6885                 {
6886                         uint32_t _flags_save_string = ndr->flags;
6887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6888                         if (r->config_file) {
6889                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
6890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
6891                         }
6892                         ndr->flags = _flags_save_string;
6893                 }
6894                 {
6895                         uint32_t _flags_save_string = ndr->flags;
6896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6897                         if (r->help_file) {
6898                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
6899                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
6900                         }
6901                         ndr->flags = _flags_save_string;
6902                 }
6903                 {
6904                         uint32_t _flags_save_string_array = ndr->flags;
6905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6906                         if (r->dependent_files) {
6907                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
6908                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
6909                         }
6910                         ndr->flags = _flags_save_string_array;
6911                 }
6912                 {
6913                         uint32_t _flags_save_string = ndr->flags;
6914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6915                         if (r->monitor_name) {
6916                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
6917                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
6918                         }
6919                         ndr->flags = _flags_save_string;
6920                 }
6921                 {
6922                         uint32_t _flags_save_string = ndr->flags;
6923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6924                         if (r->default_datatype) {
6925                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
6926                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
6927                         }
6928                         ndr->flags = _flags_save_string;
6929                 }
6930         }
6931         return NDR_ERR_SUCCESS;
6932 }
6933
6934 static enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
6935 {
6936         uint32_t _ptr_driver_name;
6937         TALLOC_CTX *_mem_save_driver_name_0;
6938         uint32_t _ptr_architecture;
6939         TALLOC_CTX *_mem_save_architecture_0;
6940         uint32_t _ptr_driver_path;
6941         TALLOC_CTX *_mem_save_driver_path_0;
6942         uint32_t _ptr_data_file;
6943         TALLOC_CTX *_mem_save_data_file_0;
6944         uint32_t _ptr_config_file;
6945         TALLOC_CTX *_mem_save_config_file_0;
6946         uint32_t _ptr_help_file;
6947         TALLOC_CTX *_mem_save_help_file_0;
6948         uint32_t _ptr_dependent_files;
6949         TALLOC_CTX *_mem_save_dependent_files_0;
6950         uint32_t _ptr_monitor_name;
6951         TALLOC_CTX *_mem_save_monitor_name_0;
6952         uint32_t _ptr_default_datatype;
6953         TALLOC_CTX *_mem_save_default_datatype_0;
6954         if (ndr_flags & NDR_SCALARS) {
6955                 NDR_CHECK(ndr_pull_align(ndr, 4));
6956                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6957                 {
6958                         uint32_t _flags_save_string = ndr->flags;
6959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6960                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6961                         if (_ptr_driver_name) {
6962                                 NDR_PULL_ALLOC(ndr, r->driver_name);
6963                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
6964                         } else {
6965                                 r->driver_name = NULL;
6966                         }
6967                         ndr->flags = _flags_save_string;
6968                 }
6969                 {
6970                         uint32_t _flags_save_string = ndr->flags;
6971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6972                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6973                         if (_ptr_architecture) {
6974                                 NDR_PULL_ALLOC(ndr, r->architecture);
6975                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
6976                         } else {
6977                                 r->architecture = NULL;
6978                         }
6979                         ndr->flags = _flags_save_string;
6980                 }
6981                 {
6982                         uint32_t _flags_save_string = ndr->flags;
6983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6984                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6985                         if (_ptr_driver_path) {
6986                                 NDR_PULL_ALLOC(ndr, r->driver_path);
6987                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
6988                         } else {
6989                                 r->driver_path = NULL;
6990                         }
6991                         ndr->flags = _flags_save_string;
6992                 }
6993                 {
6994                         uint32_t _flags_save_string = ndr->flags;
6995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6996                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6997                         if (_ptr_data_file) {
6998                                 NDR_PULL_ALLOC(ndr, r->data_file);
6999                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7000                         } else {
7001                                 r->data_file = NULL;
7002                         }
7003                         ndr->flags = _flags_save_string;
7004                 }
7005                 {
7006                         uint32_t _flags_save_string = ndr->flags;
7007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7008                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7009                         if (_ptr_config_file) {
7010                                 NDR_PULL_ALLOC(ndr, r->config_file);
7011                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7012                         } else {
7013                                 r->config_file = NULL;
7014                         }
7015                         ndr->flags = _flags_save_string;
7016                 }
7017                 {
7018                         uint32_t _flags_save_string = ndr->flags;
7019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7020                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7021                         if (_ptr_help_file) {
7022                                 NDR_PULL_ALLOC(ndr, r->help_file);
7023                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7024                         } else {
7025                                 r->help_file = NULL;
7026                         }
7027                         ndr->flags = _flags_save_string;
7028                 }
7029                 {
7030                         uint32_t _flags_save_string_array = ndr->flags;
7031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7032                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7033                         if (_ptr_dependent_files) {
7034                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7035                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7036                         } else {
7037                                 r->dependent_files = NULL;
7038                         }
7039                         ndr->flags = _flags_save_string_array;
7040                 }
7041                 {
7042                         uint32_t _flags_save_string = ndr->flags;
7043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7044                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7045                         if (_ptr_monitor_name) {
7046                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7047                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7048                         } else {
7049                                 r->monitor_name = NULL;
7050                         }
7051                         ndr->flags = _flags_save_string;
7052                 }
7053                 {
7054                         uint32_t _flags_save_string = ndr->flags;
7055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7056                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7057                         if (_ptr_default_datatype) {
7058                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7059                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7060                         } else {
7061                                 r->default_datatype = NULL;
7062                         }
7063                         ndr->flags = _flags_save_string;
7064                 }
7065         }
7066         if (ndr_flags & NDR_BUFFERS) {
7067                 {
7068                         uint32_t _flags_save_string = ndr->flags;
7069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7070                         if (r->driver_name) {
7071                                 uint32_t _relative_save_offset;
7072                                 _relative_save_offset = ndr->offset;
7073                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7074                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7075                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7076                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7077                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7078                                 ndr->offset = _relative_save_offset;
7079                         }
7080                         ndr->flags = _flags_save_string;
7081                 }
7082                 {
7083                         uint32_t _flags_save_string = ndr->flags;
7084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7085                         if (r->architecture) {
7086                                 uint32_t _relative_save_offset;
7087                                 _relative_save_offset = ndr->offset;
7088                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7089                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7090                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7091                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7092                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7093                                 ndr->offset = _relative_save_offset;
7094                         }
7095                         ndr->flags = _flags_save_string;
7096                 }
7097                 {
7098                         uint32_t _flags_save_string = ndr->flags;
7099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7100                         if (r->driver_path) {
7101                                 uint32_t _relative_save_offset;
7102                                 _relative_save_offset = ndr->offset;
7103                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7104                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7105                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7106                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7107                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7108                                 ndr->offset = _relative_save_offset;
7109                         }
7110                         ndr->flags = _flags_save_string;
7111                 }
7112                 {
7113                         uint32_t _flags_save_string = ndr->flags;
7114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7115                         if (r->data_file) {
7116                                 uint32_t _relative_save_offset;
7117                                 _relative_save_offset = ndr->offset;
7118                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7119                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7120                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7121                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7122                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7123                                 ndr->offset = _relative_save_offset;
7124                         }
7125                         ndr->flags = _flags_save_string;
7126                 }
7127                 {
7128                         uint32_t _flags_save_string = ndr->flags;
7129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7130                         if (r->config_file) {
7131                                 uint32_t _relative_save_offset;
7132                                 _relative_save_offset = ndr->offset;
7133                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7134                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7135                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7136                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7137                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7138                                 ndr->offset = _relative_save_offset;
7139                         }
7140                         ndr->flags = _flags_save_string;
7141                 }
7142                 {
7143                         uint32_t _flags_save_string = ndr->flags;
7144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7145                         if (r->help_file) {
7146                                 uint32_t _relative_save_offset;
7147                                 _relative_save_offset = ndr->offset;
7148                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7149                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7150                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7151                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7152                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7153                                 ndr->offset = _relative_save_offset;
7154                         }
7155                         ndr->flags = _flags_save_string;
7156                 }
7157                 {
7158                         uint32_t _flags_save_string_array = ndr->flags;
7159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7160                         if (r->dependent_files) {
7161                                 uint32_t _relative_save_offset;
7162                                 _relative_save_offset = ndr->offset;
7163                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7164                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7165                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7166                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7167                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7168                                 ndr->offset = _relative_save_offset;
7169                         }
7170                         ndr->flags = _flags_save_string_array;
7171                 }
7172                 {
7173                         uint32_t _flags_save_string = ndr->flags;
7174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7175                         if (r->monitor_name) {
7176                                 uint32_t _relative_save_offset;
7177                                 _relative_save_offset = ndr->offset;
7178                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7179                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7180                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7181                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7182                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7183                                 ndr->offset = _relative_save_offset;
7184                         }
7185                         ndr->flags = _flags_save_string;
7186                 }
7187                 {
7188                         uint32_t _flags_save_string = ndr->flags;
7189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7190                         if (r->default_datatype) {
7191                                 uint32_t _relative_save_offset;
7192                                 _relative_save_offset = ndr->offset;
7193                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7194                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7195                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7196                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7197                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7198                                 ndr->offset = _relative_save_offset;
7199                         }
7200                         ndr->flags = _flags_save_string;
7201                 }
7202         }
7203         return NDR_ERR_SUCCESS;
7204 }
7205
7206 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
7207 {
7208         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
7209         ndr->depth++;
7210         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7211         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7212         ndr->depth++;
7213         if (r->driver_name) {
7214                 ndr_print_string(ndr, "driver_name", r->driver_name);
7215         }
7216         ndr->depth--;
7217         ndr_print_ptr(ndr, "architecture", r->architecture);
7218         ndr->depth++;
7219         if (r->architecture) {
7220                 ndr_print_string(ndr, "architecture", r->architecture);
7221         }
7222         ndr->depth--;
7223         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7224         ndr->depth++;
7225         if (r->driver_path) {
7226                 ndr_print_string(ndr, "driver_path", r->driver_path);
7227         }
7228         ndr->depth--;
7229         ndr_print_ptr(ndr, "data_file", r->data_file);
7230         ndr->depth++;
7231         if (r->data_file) {
7232                 ndr_print_string(ndr, "data_file", r->data_file);
7233         }
7234         ndr->depth--;
7235         ndr_print_ptr(ndr, "config_file", r->config_file);
7236         ndr->depth++;
7237         if (r->config_file) {
7238                 ndr_print_string(ndr, "config_file", r->config_file);
7239         }
7240         ndr->depth--;
7241         ndr_print_ptr(ndr, "help_file", r->help_file);
7242         ndr->depth++;
7243         if (r->help_file) {
7244                 ndr_print_string(ndr, "help_file", r->help_file);
7245         }
7246         ndr->depth--;
7247         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7248         ndr->depth++;
7249         if (r->dependent_files) {
7250                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7251         }
7252         ndr->depth--;
7253         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7254         ndr->depth++;
7255         if (r->monitor_name) {
7256                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7257         }
7258         ndr->depth--;
7259         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7260         ndr->depth++;
7261         if (r->default_datatype) {
7262                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7263         }
7264         ndr->depth--;
7265         ndr->depth--;
7266 }
7267
7268 static enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
7269 {
7270         if (ndr_flags & NDR_SCALARS) {
7271                 NDR_CHECK(ndr_push_align(ndr, 4));
7272                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7273                 {
7274                         uint32_t _flags_save_string = ndr->flags;
7275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7276                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7277                         ndr->flags = _flags_save_string;
7278                 }
7279                 {
7280                         uint32_t _flags_save_string = ndr->flags;
7281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7282                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7283                         ndr->flags = _flags_save_string;
7284                 }
7285                 {
7286                         uint32_t _flags_save_string = ndr->flags;
7287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7289                         ndr->flags = _flags_save_string;
7290                 }
7291                 {
7292                         uint32_t _flags_save_string = ndr->flags;
7293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7295                         ndr->flags = _flags_save_string;
7296                 }
7297                 {
7298                         uint32_t _flags_save_string = ndr->flags;
7299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7301                         ndr->flags = _flags_save_string;
7302                 }
7303                 {
7304                         uint32_t _flags_save_string = ndr->flags;
7305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
7307                         ndr->flags = _flags_save_string;
7308                 }
7309                 {
7310                         uint32_t _flags_save_string_array = ndr->flags;
7311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
7313                         ndr->flags = _flags_save_string_array;
7314                 }
7315                 {
7316                         uint32_t _flags_save_string = ndr->flags;
7317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7319                         ndr->flags = _flags_save_string;
7320                 }
7321                 {
7322                         uint32_t _flags_save_string = ndr->flags;
7323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
7325                         ndr->flags = _flags_save_string;
7326                 }
7327                 {
7328                         uint32_t _flags_save_string_array = ndr->flags;
7329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7330                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
7331                         ndr->flags = _flags_save_string_array;
7332                 }
7333         }
7334         if (ndr_flags & NDR_BUFFERS) {
7335                 {
7336                         uint32_t _flags_save_string = ndr->flags;
7337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7338                         if (r->driver_name) {
7339                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7340                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7341                         }
7342                         ndr->flags = _flags_save_string;
7343                 }
7344                 {
7345                         uint32_t _flags_save_string = ndr->flags;
7346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7347                         if (r->architecture) {
7348                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7349                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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                         if (r->driver_path) {
7357                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7358                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7359                         }
7360                         ndr->flags = _flags_save_string;
7361                 }
7362                 {
7363                         uint32_t _flags_save_string = ndr->flags;
7364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7365                         if (r->data_file) {
7366                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7367                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7368                         }
7369                         ndr->flags = _flags_save_string;
7370                 }
7371                 {
7372                         uint32_t _flags_save_string = ndr->flags;
7373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7374                         if (r->config_file) {
7375                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7376                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7377                         }
7378                         ndr->flags = _flags_save_string;
7379                 }
7380                 {
7381                         uint32_t _flags_save_string = ndr->flags;
7382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7383                         if (r->help_file) {
7384                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
7385                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
7386                         }
7387                         ndr->flags = _flags_save_string;
7388                 }
7389                 {
7390                         uint32_t _flags_save_string_array = ndr->flags;
7391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7392                         if (r->dependent_files) {
7393                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
7394                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
7395                         }
7396                         ndr->flags = _flags_save_string_array;
7397                 }
7398                 {
7399                         uint32_t _flags_save_string = ndr->flags;
7400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7401                         if (r->monitor_name) {
7402                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7403                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7404                         }
7405                         ndr->flags = _flags_save_string;
7406                 }
7407                 {
7408                         uint32_t _flags_save_string = ndr->flags;
7409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7410                         if (r->default_datatype) {
7411                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
7412                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
7413                         }
7414                         ndr->flags = _flags_save_string;
7415                 }
7416                 {
7417                         uint32_t _flags_save_string_array = ndr->flags;
7418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7419                         if (r->previous_names) {
7420                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
7421                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
7422                         }
7423                         ndr->flags = _flags_save_string_array;
7424                 }
7425         }
7426         return NDR_ERR_SUCCESS;
7427 }
7428
7429 static enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
7430 {
7431         uint32_t _ptr_driver_name;
7432         TALLOC_CTX *_mem_save_driver_name_0;
7433         uint32_t _ptr_architecture;
7434         TALLOC_CTX *_mem_save_architecture_0;
7435         uint32_t _ptr_driver_path;
7436         TALLOC_CTX *_mem_save_driver_path_0;
7437         uint32_t _ptr_data_file;
7438         TALLOC_CTX *_mem_save_data_file_0;
7439         uint32_t _ptr_config_file;
7440         TALLOC_CTX *_mem_save_config_file_0;
7441         uint32_t _ptr_help_file;
7442         TALLOC_CTX *_mem_save_help_file_0;
7443         uint32_t _ptr_dependent_files;
7444         TALLOC_CTX *_mem_save_dependent_files_0;
7445         uint32_t _ptr_monitor_name;
7446         TALLOC_CTX *_mem_save_monitor_name_0;
7447         uint32_t _ptr_default_datatype;
7448         TALLOC_CTX *_mem_save_default_datatype_0;
7449         uint32_t _ptr_previous_names;
7450         TALLOC_CTX *_mem_save_previous_names_0;
7451         if (ndr_flags & NDR_SCALARS) {
7452                 NDR_CHECK(ndr_pull_align(ndr, 4));
7453                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7454                 {
7455                         uint32_t _flags_save_string = ndr->flags;
7456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7457                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7458                         if (_ptr_driver_name) {
7459                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7460                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7461                         } else {
7462                                 r->driver_name = NULL;
7463                         }
7464                         ndr->flags = _flags_save_string;
7465                 }
7466                 {
7467                         uint32_t _flags_save_string = ndr->flags;
7468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7469                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7470                         if (_ptr_architecture) {
7471                                 NDR_PULL_ALLOC(ndr, r->architecture);
7472                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7473                         } else {
7474                                 r->architecture = NULL;
7475                         }
7476                         ndr->flags = _flags_save_string;
7477                 }
7478                 {
7479                         uint32_t _flags_save_string = ndr->flags;
7480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7481                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7482                         if (_ptr_driver_path) {
7483                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7484                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7485                         } else {
7486                                 r->driver_path = NULL;
7487                         }
7488                         ndr->flags = _flags_save_string;
7489                 }
7490                 {
7491                         uint32_t _flags_save_string = ndr->flags;
7492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7493                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7494                         if (_ptr_data_file) {
7495                                 NDR_PULL_ALLOC(ndr, r->data_file);
7496                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7497                         } else {
7498                                 r->data_file = NULL;
7499                         }
7500                         ndr->flags = _flags_save_string;
7501                 }
7502                 {
7503                         uint32_t _flags_save_string = ndr->flags;
7504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7505                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7506                         if (_ptr_config_file) {
7507                                 NDR_PULL_ALLOC(ndr, r->config_file);
7508                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7509                         } else {
7510                                 r->config_file = NULL;
7511                         }
7512                         ndr->flags = _flags_save_string;
7513                 }
7514                 {
7515                         uint32_t _flags_save_string = ndr->flags;
7516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7517                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7518                         if (_ptr_help_file) {
7519                                 NDR_PULL_ALLOC(ndr, r->help_file);
7520                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7521                         } else {
7522                                 r->help_file = NULL;
7523                         }
7524                         ndr->flags = _flags_save_string;
7525                 }
7526                 {
7527                         uint32_t _flags_save_string_array = ndr->flags;
7528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7529                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7530                         if (_ptr_dependent_files) {
7531                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7532                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7533                         } else {
7534                                 r->dependent_files = NULL;
7535                         }
7536                         ndr->flags = _flags_save_string_array;
7537                 }
7538                 {
7539                         uint32_t _flags_save_string = ndr->flags;
7540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7541                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7542                         if (_ptr_monitor_name) {
7543                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7544                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7545                         } else {
7546                                 r->monitor_name = NULL;
7547                         }
7548                         ndr->flags = _flags_save_string;
7549                 }
7550                 {
7551                         uint32_t _flags_save_string = ndr->flags;
7552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7553                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7554                         if (_ptr_default_datatype) {
7555                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7556                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7557                         } else {
7558                                 r->default_datatype = NULL;
7559                         }
7560                         ndr->flags = _flags_save_string;
7561                 }
7562                 {
7563                         uint32_t _flags_save_string_array = ndr->flags;
7564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7565                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
7566                         if (_ptr_previous_names) {
7567                                 NDR_PULL_ALLOC(ndr, r->previous_names);
7568                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
7569                         } else {
7570                                 r->previous_names = NULL;
7571                         }
7572                         ndr->flags = _flags_save_string_array;
7573                 }
7574         }
7575         if (ndr_flags & NDR_BUFFERS) {
7576                 {
7577                         uint32_t _flags_save_string = ndr->flags;
7578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7579                         if (r->driver_name) {
7580                                 uint32_t _relative_save_offset;
7581                                 _relative_save_offset = ndr->offset;
7582                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7583                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7584                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7585                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7586                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7587                                 ndr->offset = _relative_save_offset;
7588                         }
7589                         ndr->flags = _flags_save_string;
7590                 }
7591                 {
7592                         uint32_t _flags_save_string = ndr->flags;
7593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7594                         if (r->architecture) {
7595                                 uint32_t _relative_save_offset;
7596                                 _relative_save_offset = ndr->offset;
7597                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7598                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7599                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7600                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7601                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7602                                 ndr->offset = _relative_save_offset;
7603                         }
7604                         ndr->flags = _flags_save_string;
7605                 }
7606                 {
7607                         uint32_t _flags_save_string = ndr->flags;
7608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7609                         if (r->driver_path) {
7610                                 uint32_t _relative_save_offset;
7611                                 _relative_save_offset = ndr->offset;
7612                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7613                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7614                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7615                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7616                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7617                                 ndr->offset = _relative_save_offset;
7618                         }
7619                         ndr->flags = _flags_save_string;
7620                 }
7621                 {
7622                         uint32_t _flags_save_string = ndr->flags;
7623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7624                         if (r->data_file) {
7625                                 uint32_t _relative_save_offset;
7626                                 _relative_save_offset = ndr->offset;
7627                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7628                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7629                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7630                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7631                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7632                                 ndr->offset = _relative_save_offset;
7633                         }
7634                         ndr->flags = _flags_save_string;
7635                 }
7636                 {
7637                         uint32_t _flags_save_string = ndr->flags;
7638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7639                         if (r->config_file) {
7640                                 uint32_t _relative_save_offset;
7641                                 _relative_save_offset = ndr->offset;
7642                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7643                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7644                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7645                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7646                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7647                                 ndr->offset = _relative_save_offset;
7648                         }
7649                         ndr->flags = _flags_save_string;
7650                 }
7651                 {
7652                         uint32_t _flags_save_string = ndr->flags;
7653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7654                         if (r->help_file) {
7655                                 uint32_t _relative_save_offset;
7656                                 _relative_save_offset = ndr->offset;
7657                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7658                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7659                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7660                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7661                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7662                                 ndr->offset = _relative_save_offset;
7663                         }
7664                         ndr->flags = _flags_save_string;
7665                 }
7666                 {
7667                         uint32_t _flags_save_string_array = ndr->flags;
7668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7669                         if (r->dependent_files) {
7670                                 uint32_t _relative_save_offset;
7671                                 _relative_save_offset = ndr->offset;
7672                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7673                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7674                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7675                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7676                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7677                                 ndr->offset = _relative_save_offset;
7678                         }
7679                         ndr->flags = _flags_save_string_array;
7680                 }
7681                 {
7682                         uint32_t _flags_save_string = ndr->flags;
7683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7684                         if (r->monitor_name) {
7685                                 uint32_t _relative_save_offset;
7686                                 _relative_save_offset = ndr->offset;
7687                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7688                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7689                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7690                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7691                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7692                                 ndr->offset = _relative_save_offset;
7693                         }
7694                         ndr->flags = _flags_save_string;
7695                 }
7696                 {
7697                         uint32_t _flags_save_string = ndr->flags;
7698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7699                         if (r->default_datatype) {
7700                                 uint32_t _relative_save_offset;
7701                                 _relative_save_offset = ndr->offset;
7702                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7703                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7704                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7705                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7706                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7707                                 ndr->offset = _relative_save_offset;
7708                         }
7709                         ndr->flags = _flags_save_string;
7710                 }
7711                 {
7712                         uint32_t _flags_save_string_array = ndr->flags;
7713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7714                         if (r->previous_names) {
7715                                 uint32_t _relative_save_offset;
7716                                 _relative_save_offset = ndr->offset;
7717                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
7718                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7719                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
7720                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
7721                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
7722                                 ndr->offset = _relative_save_offset;
7723                         }
7724                         ndr->flags = _flags_save_string_array;
7725                 }
7726         }
7727         return NDR_ERR_SUCCESS;
7728 }
7729
7730 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
7731 {
7732         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
7733         ndr->depth++;
7734         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7735         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7736         ndr->depth++;
7737         if (r->driver_name) {
7738                 ndr_print_string(ndr, "driver_name", r->driver_name);
7739         }
7740         ndr->depth--;
7741         ndr_print_ptr(ndr, "architecture", r->architecture);
7742         ndr->depth++;
7743         if (r->architecture) {
7744                 ndr_print_string(ndr, "architecture", r->architecture);
7745         }
7746         ndr->depth--;
7747         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7748         ndr->depth++;
7749         if (r->driver_path) {
7750                 ndr_print_string(ndr, "driver_path", r->driver_path);
7751         }
7752         ndr->depth--;
7753         ndr_print_ptr(ndr, "data_file", r->data_file);
7754         ndr->depth++;
7755         if (r->data_file) {
7756                 ndr_print_string(ndr, "data_file", r->data_file);
7757         }
7758         ndr->depth--;
7759         ndr_print_ptr(ndr, "config_file", r->config_file);
7760         ndr->depth++;
7761         if (r->config_file) {
7762                 ndr_print_string(ndr, "config_file", r->config_file);
7763         }
7764         ndr->depth--;
7765         ndr_print_ptr(ndr, "help_file", r->help_file);
7766         ndr->depth++;
7767         if (r->help_file) {
7768                 ndr_print_string(ndr, "help_file", r->help_file);
7769         }
7770         ndr->depth--;
7771         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7772         ndr->depth++;
7773         if (r->dependent_files) {
7774                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7775         }
7776         ndr->depth--;
7777         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7778         ndr->depth++;
7779         if (r->monitor_name) {
7780                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7781         }
7782         ndr->depth--;
7783         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7784         ndr->depth++;
7785         if (r->default_datatype) {
7786                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7787         }
7788         ndr->depth--;
7789         ndr_print_ptr(ndr, "previous_names", r->previous_names);
7790         ndr->depth++;
7791         if (r->previous_names) {
7792                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
7793         }
7794         ndr->depth--;
7795         ndr->depth--;
7796 }
7797
7798 static enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
7799 {
7800         if (ndr_flags & NDR_SCALARS) {
7801                 NDR_CHECK(ndr_push_align(ndr, 4));
7802                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7803                 {
7804                         uint32_t _flags_save_string = ndr->flags;
7805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7806                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7807                         ndr->flags = _flags_save_string;
7808                 }
7809                 {
7810                         uint32_t _flags_save_string = ndr->flags;
7811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7812                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7813                         ndr->flags = _flags_save_string;
7814                 }
7815                 {
7816                         uint32_t _flags_save_string = ndr->flags;
7817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7818                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7819                         ndr->flags = _flags_save_string;
7820                 }
7821                 {
7822                         uint32_t _flags_save_string = ndr->flags;
7823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7824                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7825                         ndr->flags = _flags_save_string;
7826                 }
7827                 {
7828                         uint32_t _flags_save_string = ndr->flags;
7829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7830                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7831                         ndr->flags = _flags_save_string;
7832                 }
7833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
7834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
7835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
7836         }
7837         if (ndr_flags & NDR_BUFFERS) {
7838                 {
7839                         uint32_t _flags_save_string = ndr->flags;
7840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7841                         if (r->driver_name) {
7842                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7843                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
7851                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7852                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7853                         }
7854                         ndr->flags = _flags_save_string;
7855                 }
7856                 {
7857                         uint32_t _flags_save_string = ndr->flags;
7858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7859                         if (r->driver_path) {
7860                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7861                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7862                         }
7863                         ndr->flags = _flags_save_string;
7864                 }
7865                 {
7866                         uint32_t _flags_save_string = ndr->flags;
7867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7868                         if (r->data_file) {
7869                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7870                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7871                         }
7872                         ndr->flags = _flags_save_string;
7873                 }
7874                 {
7875                         uint32_t _flags_save_string = ndr->flags;
7876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7877                         if (r->config_file) {
7878                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7879                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7880                         }
7881                         ndr->flags = _flags_save_string;
7882                 }
7883         }
7884         return NDR_ERR_SUCCESS;
7885 }
7886
7887 static enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
7888 {
7889         uint32_t _ptr_driver_name;
7890         TALLOC_CTX *_mem_save_driver_name_0;
7891         uint32_t _ptr_architecture;
7892         TALLOC_CTX *_mem_save_architecture_0;
7893         uint32_t _ptr_driver_path;
7894         TALLOC_CTX *_mem_save_driver_path_0;
7895         uint32_t _ptr_data_file;
7896         TALLOC_CTX *_mem_save_data_file_0;
7897         uint32_t _ptr_config_file;
7898         TALLOC_CTX *_mem_save_config_file_0;
7899         if (ndr_flags & NDR_SCALARS) {
7900                 NDR_CHECK(ndr_pull_align(ndr, 4));
7901                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7902                 {
7903                         uint32_t _flags_save_string = ndr->flags;
7904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7905                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7906                         if (_ptr_driver_name) {
7907                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7908                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7909                         } else {
7910                                 r->driver_name = NULL;
7911                         }
7912                         ndr->flags = _flags_save_string;
7913                 }
7914                 {
7915                         uint32_t _flags_save_string = ndr->flags;
7916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7917                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7918                         if (_ptr_architecture) {
7919                                 NDR_PULL_ALLOC(ndr, r->architecture);
7920                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7921                         } else {
7922                                 r->architecture = NULL;
7923                         }
7924                         ndr->flags = _flags_save_string;
7925                 }
7926                 {
7927                         uint32_t _flags_save_string = ndr->flags;
7928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7929                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7930                         if (_ptr_driver_path) {
7931                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7932                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7933                         } else {
7934                                 r->driver_path = NULL;
7935                         }
7936                         ndr->flags = _flags_save_string;
7937                 }
7938                 {
7939                         uint32_t _flags_save_string = ndr->flags;
7940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7941                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7942                         if (_ptr_data_file) {
7943                                 NDR_PULL_ALLOC(ndr, r->data_file);
7944                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7945                         } else {
7946                                 r->data_file = NULL;
7947                         }
7948                         ndr->flags = _flags_save_string;
7949                 }
7950                 {
7951                         uint32_t _flags_save_string = ndr->flags;
7952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7953                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7954                         if (_ptr_config_file) {
7955                                 NDR_PULL_ALLOC(ndr, r->config_file);
7956                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7957                         } else {
7958                                 r->config_file = NULL;
7959                         }
7960                         ndr->flags = _flags_save_string;
7961                 }
7962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
7963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
7964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
7965         }
7966         if (ndr_flags & NDR_BUFFERS) {
7967                 {
7968                         uint32_t _flags_save_string = ndr->flags;
7969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7970                         if (r->driver_name) {
7971                                 uint32_t _relative_save_offset;
7972                                 _relative_save_offset = ndr->offset;
7973                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7974                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7975                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7976                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7977                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7978                                 ndr->offset = _relative_save_offset;
7979                         }
7980                         ndr->flags = _flags_save_string;
7981                 }
7982                 {
7983                         uint32_t _flags_save_string = ndr->flags;
7984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7985                         if (r->architecture) {
7986                                 uint32_t _relative_save_offset;
7987                                 _relative_save_offset = ndr->offset;
7988                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7989                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7990                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7991                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7992                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7993                                 ndr->offset = _relative_save_offset;
7994                         }
7995                         ndr->flags = _flags_save_string;
7996                 }
7997                 {
7998                         uint32_t _flags_save_string = ndr->flags;
7999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8000                         if (r->driver_path) {
8001                                 uint32_t _relative_save_offset;
8002                                 _relative_save_offset = ndr->offset;
8003                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8004                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8005                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8006                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8007                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8008                                 ndr->offset = _relative_save_offset;
8009                         }
8010                         ndr->flags = _flags_save_string;
8011                 }
8012                 {
8013                         uint32_t _flags_save_string = ndr->flags;
8014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8015                         if (r->data_file) {
8016                                 uint32_t _relative_save_offset;
8017                                 _relative_save_offset = ndr->offset;
8018                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8019                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8020                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8021                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8022                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8023                                 ndr->offset = _relative_save_offset;
8024                         }
8025                         ndr->flags = _flags_save_string;
8026                 }
8027                 {
8028                         uint32_t _flags_save_string = ndr->flags;
8029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8030                         if (r->config_file) {
8031                                 uint32_t _relative_save_offset;
8032                                 _relative_save_offset = ndr->offset;
8033                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8034                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8035                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8036                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8037                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8038                                 ndr->offset = _relative_save_offset;
8039                         }
8040                         ndr->flags = _flags_save_string;
8041                 }
8042         }
8043         return NDR_ERR_SUCCESS;
8044 }
8045
8046 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
8047 {
8048         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
8049         ndr->depth++;
8050         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8051         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8052         ndr->depth++;
8053         if (r->driver_name) {
8054                 ndr_print_string(ndr, "driver_name", r->driver_name);
8055         }
8056         ndr->depth--;
8057         ndr_print_ptr(ndr, "architecture", r->architecture);
8058         ndr->depth++;
8059         if (r->architecture) {
8060                 ndr_print_string(ndr, "architecture", r->architecture);
8061         }
8062         ndr->depth--;
8063         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8064         ndr->depth++;
8065         if (r->driver_path) {
8066                 ndr_print_string(ndr, "driver_path", r->driver_path);
8067         }
8068         ndr->depth--;
8069         ndr_print_ptr(ndr, "data_file", r->data_file);
8070         ndr->depth++;
8071         if (r->data_file) {
8072                 ndr_print_string(ndr, "data_file", r->data_file);
8073         }
8074         ndr->depth--;
8075         ndr_print_ptr(ndr, "config_file", r->config_file);
8076         ndr->depth++;
8077         if (r->config_file) {
8078                 ndr_print_string(ndr, "config_file", r->config_file);
8079         }
8080         ndr->depth--;
8081         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
8082         ndr_print_uint32(ndr, "config_version", r->config_version);
8083         ndr_print_uint32(ndr, "driver_version", r->driver_version);
8084         ndr->depth--;
8085 }
8086
8087 static enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
8088 {
8089         if (ndr_flags & NDR_SCALARS) {
8090                 NDR_CHECK(ndr_push_align(ndr, 8));
8091                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8092                 {
8093                         uint32_t _flags_save_string = ndr->flags;
8094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8095                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8096                         ndr->flags = _flags_save_string;
8097                 }
8098                 {
8099                         uint32_t _flags_save_string = ndr->flags;
8100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8101                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8102                         ndr->flags = _flags_save_string;
8103                 }
8104                 {
8105                         uint32_t _flags_save_string = ndr->flags;
8106                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8107                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8108                         ndr->flags = _flags_save_string;
8109                 }
8110                 {
8111                         uint32_t _flags_save_string = ndr->flags;
8112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8113                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8114                         ndr->flags = _flags_save_string;
8115                 }
8116                 {
8117                         uint32_t _flags_save_string = ndr->flags;
8118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8119                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8120                         ndr->flags = _flags_save_string;
8121                 }
8122                 {
8123                         uint32_t _flags_save_string = ndr->flags;
8124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8125                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8126                         ndr->flags = _flags_save_string;
8127                 }
8128                 {
8129                         uint32_t _flags_save_string_array = ndr->flags;
8130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8131                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8132                         ndr->flags = _flags_save_string_array;
8133                 }
8134                 {
8135                         uint32_t _flags_save_string = ndr->flags;
8136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8137                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8138                         ndr->flags = _flags_save_string;
8139                 }
8140                 {
8141                         uint32_t _flags_save_string = ndr->flags;
8142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8143                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8144                         ndr->flags = _flags_save_string;
8145                 }
8146                 {
8147                         uint32_t _flags_save_string_array = ndr->flags;
8148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8149                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8150                         ndr->flags = _flags_save_string_array;
8151                 }
8152                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
8153                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8154                 {
8155                         uint32_t _flags_save_string = ndr->flags;
8156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8157                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
8158                         ndr->flags = _flags_save_string;
8159                 }
8160                 {
8161                         uint32_t _flags_save_string = ndr->flags;
8162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8163                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
8164                         ndr->flags = _flags_save_string;
8165                 }
8166                 {
8167                         uint32_t _flags_save_string = ndr->flags;
8168                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8169                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
8170                         ndr->flags = _flags_save_string;
8171                 }
8172                 {
8173                         uint32_t _flags_save_string = ndr->flags;
8174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8175                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
8176                         ndr->flags = _flags_save_string;
8177                 }
8178         }
8179         if (ndr_flags & NDR_BUFFERS) {
8180                 {
8181                         uint32_t _flags_save_string = ndr->flags;
8182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8183                         if (r->driver_name) {
8184                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8185                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8186                         }
8187                         ndr->flags = _flags_save_string;
8188                 }
8189                 {
8190                         uint32_t _flags_save_string = ndr->flags;
8191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8192                         if (r->architecture) {
8193                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8194                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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                         if (r->driver_path) {
8202                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8203                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8204                         }
8205                         ndr->flags = _flags_save_string;
8206                 }
8207                 {
8208                         uint32_t _flags_save_string = ndr->flags;
8209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8210                         if (r->data_file) {
8211                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8212                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8213                         }
8214                         ndr->flags = _flags_save_string;
8215                 }
8216                 {
8217                         uint32_t _flags_save_string = ndr->flags;
8218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8219                         if (r->config_file) {
8220                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8221                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8222                         }
8223                         ndr->flags = _flags_save_string;
8224                 }
8225                 {
8226                         uint32_t _flags_save_string = ndr->flags;
8227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8228                         if (r->help_file) {
8229                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8230                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8231                         }
8232                         ndr->flags = _flags_save_string;
8233                 }
8234                 {
8235                         uint32_t _flags_save_string_array = ndr->flags;
8236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8237                         if (r->dependent_files) {
8238                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8239                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8240                         }
8241                         ndr->flags = _flags_save_string_array;
8242                 }
8243                 {
8244                         uint32_t _flags_save_string = ndr->flags;
8245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8246                         if (r->monitor_name) {
8247                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8248                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8249                         }
8250                         ndr->flags = _flags_save_string;
8251                 }
8252                 {
8253                         uint32_t _flags_save_string = ndr->flags;
8254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8255                         if (r->default_datatype) {
8256                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8257                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8258                         }
8259                         ndr->flags = _flags_save_string;
8260                 }
8261                 {
8262                         uint32_t _flags_save_string_array = ndr->flags;
8263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8264                         if (r->previous_names) {
8265                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8266                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8267                         }
8268                         ndr->flags = _flags_save_string_array;
8269                 }
8270                 {
8271                         uint32_t _flags_save_string = ndr->flags;
8272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8273                         if (r->manufacturer_name) {
8274                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
8275                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
8276                         }
8277                         ndr->flags = _flags_save_string;
8278                 }
8279                 {
8280                         uint32_t _flags_save_string = ndr->flags;
8281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8282                         if (r->manufacturer_url) {
8283                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
8284                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
8285                         }
8286                         ndr->flags = _flags_save_string;
8287                 }
8288                 {
8289                         uint32_t _flags_save_string = ndr->flags;
8290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8291                         if (r->hardware_id) {
8292                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
8293                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
8294                         }
8295                         ndr->flags = _flags_save_string;
8296                 }
8297                 {
8298                         uint32_t _flags_save_string = ndr->flags;
8299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8300                         if (r->provider) {
8301                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
8302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
8303                         }
8304                         ndr->flags = _flags_save_string;
8305                 }
8306         }
8307         return NDR_ERR_SUCCESS;
8308 }
8309
8310 static enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
8311 {
8312         uint32_t _ptr_driver_name;
8313         TALLOC_CTX *_mem_save_driver_name_0;
8314         uint32_t _ptr_architecture;
8315         TALLOC_CTX *_mem_save_architecture_0;
8316         uint32_t _ptr_driver_path;
8317         TALLOC_CTX *_mem_save_driver_path_0;
8318         uint32_t _ptr_data_file;
8319         TALLOC_CTX *_mem_save_data_file_0;
8320         uint32_t _ptr_config_file;
8321         TALLOC_CTX *_mem_save_config_file_0;
8322         uint32_t _ptr_help_file;
8323         TALLOC_CTX *_mem_save_help_file_0;
8324         uint32_t _ptr_dependent_files;
8325         TALLOC_CTX *_mem_save_dependent_files_0;
8326         uint32_t _ptr_monitor_name;
8327         TALLOC_CTX *_mem_save_monitor_name_0;
8328         uint32_t _ptr_default_datatype;
8329         TALLOC_CTX *_mem_save_default_datatype_0;
8330         uint32_t _ptr_previous_names;
8331         TALLOC_CTX *_mem_save_previous_names_0;
8332         uint32_t _ptr_manufacturer_name;
8333         TALLOC_CTX *_mem_save_manufacturer_name_0;
8334         uint32_t _ptr_manufacturer_url;
8335         TALLOC_CTX *_mem_save_manufacturer_url_0;
8336         uint32_t _ptr_hardware_id;
8337         TALLOC_CTX *_mem_save_hardware_id_0;
8338         uint32_t _ptr_provider;
8339         TALLOC_CTX *_mem_save_provider_0;
8340         if (ndr_flags & NDR_SCALARS) {
8341                 NDR_CHECK(ndr_pull_align(ndr, 8));
8342                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8343                 {
8344                         uint32_t _flags_save_string = ndr->flags;
8345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8346                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8347                         if (_ptr_driver_name) {
8348                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8349                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8350                         } else {
8351                                 r->driver_name = NULL;
8352                         }
8353                         ndr->flags = _flags_save_string;
8354                 }
8355                 {
8356                         uint32_t _flags_save_string = ndr->flags;
8357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8358                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8359                         if (_ptr_architecture) {
8360                                 NDR_PULL_ALLOC(ndr, r->architecture);
8361                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8362                         } else {
8363                                 r->architecture = NULL;
8364                         }
8365                         ndr->flags = _flags_save_string;
8366                 }
8367                 {
8368                         uint32_t _flags_save_string = ndr->flags;
8369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8370                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8371                         if (_ptr_driver_path) {
8372                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8373                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8374                         } else {
8375                                 r->driver_path = NULL;
8376                         }
8377                         ndr->flags = _flags_save_string;
8378                 }
8379                 {
8380                         uint32_t _flags_save_string = ndr->flags;
8381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8382                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8383                         if (_ptr_data_file) {
8384                                 NDR_PULL_ALLOC(ndr, r->data_file);
8385                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8386                         } else {
8387                                 r->data_file = NULL;
8388                         }
8389                         ndr->flags = _flags_save_string;
8390                 }
8391                 {
8392                         uint32_t _flags_save_string = ndr->flags;
8393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8394                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8395                         if (_ptr_config_file) {
8396                                 NDR_PULL_ALLOC(ndr, r->config_file);
8397                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8398                         } else {
8399                                 r->config_file = NULL;
8400                         }
8401                         ndr->flags = _flags_save_string;
8402                 }
8403                 {
8404                         uint32_t _flags_save_string = ndr->flags;
8405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8406                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8407                         if (_ptr_help_file) {
8408                                 NDR_PULL_ALLOC(ndr, r->help_file);
8409                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
8410                         } else {
8411                                 r->help_file = NULL;
8412                         }
8413                         ndr->flags = _flags_save_string;
8414                 }
8415                 {
8416                         uint32_t _flags_save_string_array = ndr->flags;
8417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8418                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8419                         if (_ptr_dependent_files) {
8420                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
8421                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
8422                         } else {
8423                                 r->dependent_files = NULL;
8424                         }
8425                         ndr->flags = _flags_save_string_array;
8426                 }
8427                 {
8428                         uint32_t _flags_save_string = ndr->flags;
8429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8430                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8431                         if (_ptr_monitor_name) {
8432                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
8433                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
8434                         } else {
8435                                 r->monitor_name = NULL;
8436                         }
8437                         ndr->flags = _flags_save_string;
8438                 }
8439                 {
8440                         uint32_t _flags_save_string = ndr->flags;
8441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8442                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8443                         if (_ptr_default_datatype) {
8444                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
8445                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
8446                         } else {
8447                                 r->default_datatype = NULL;
8448                         }
8449                         ndr->flags = _flags_save_string;
8450                 }
8451                 {
8452                         uint32_t _flags_save_string_array = ndr->flags;
8453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8454                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8455                         if (_ptr_previous_names) {
8456                                 NDR_PULL_ALLOC(ndr, r->previous_names);
8457                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
8458                         } else {
8459                                 r->previous_names = NULL;
8460                         }
8461                         ndr->flags = _flags_save_string_array;
8462                 }
8463                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
8464                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8465                 {
8466                         uint32_t _flags_save_string = ndr->flags;
8467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8468                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8469                         if (_ptr_manufacturer_name) {
8470                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8471                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
8472                         } else {
8473                                 r->manufacturer_name = NULL;
8474                         }
8475                         ndr->flags = _flags_save_string;
8476                 }
8477                 {
8478                         uint32_t _flags_save_string = ndr->flags;
8479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8480                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8481                         if (_ptr_manufacturer_url) {
8482                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8483                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
8484                         } else {
8485                                 r->manufacturer_url = NULL;
8486                         }
8487                         ndr->flags = _flags_save_string;
8488                 }
8489                 {
8490                         uint32_t _flags_save_string = ndr->flags;
8491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8492                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8493                         if (_ptr_hardware_id) {
8494                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
8495                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
8496                         } else {
8497                                 r->hardware_id = NULL;
8498                         }
8499                         ndr->flags = _flags_save_string;
8500                 }
8501                 {
8502                         uint32_t _flags_save_string = ndr->flags;
8503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8504                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8505                         if (_ptr_provider) {
8506                                 NDR_PULL_ALLOC(ndr, r->provider);
8507                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
8508                         } else {
8509                                 r->provider = NULL;
8510                         }
8511                         ndr->flags = _flags_save_string;
8512                 }
8513         }
8514         if (ndr_flags & NDR_BUFFERS) {
8515                 {
8516                         uint32_t _flags_save_string = ndr->flags;
8517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8518                         if (r->driver_name) {
8519                                 uint32_t _relative_save_offset;
8520                                 _relative_save_offset = ndr->offset;
8521                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8522                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8523                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8524                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8525                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8526                                 ndr->offset = _relative_save_offset;
8527                         }
8528                         ndr->flags = _flags_save_string;
8529                 }
8530                 {
8531                         uint32_t _flags_save_string = ndr->flags;
8532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8533                         if (r->architecture) {
8534                                 uint32_t _relative_save_offset;
8535                                 _relative_save_offset = ndr->offset;
8536                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8537                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8538                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8539                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8540                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8541                                 ndr->offset = _relative_save_offset;
8542                         }
8543                         ndr->flags = _flags_save_string;
8544                 }
8545                 {
8546                         uint32_t _flags_save_string = ndr->flags;
8547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8548                         if (r->driver_path) {
8549                                 uint32_t _relative_save_offset;
8550                                 _relative_save_offset = ndr->offset;
8551                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8552                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8553                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8554                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8555                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8556                                 ndr->offset = _relative_save_offset;
8557                         }
8558                         ndr->flags = _flags_save_string;
8559                 }
8560                 {
8561                         uint32_t _flags_save_string = ndr->flags;
8562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8563                         if (r->data_file) {
8564                                 uint32_t _relative_save_offset;
8565                                 _relative_save_offset = ndr->offset;
8566                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8567                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8568                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8569                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8570                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8571                                 ndr->offset = _relative_save_offset;
8572                         }
8573                         ndr->flags = _flags_save_string;
8574                 }
8575                 {
8576                         uint32_t _flags_save_string = ndr->flags;
8577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8578                         if (r->config_file) {
8579                                 uint32_t _relative_save_offset;
8580                                 _relative_save_offset = ndr->offset;
8581                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8582                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8583                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8584                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8585                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8586                                 ndr->offset = _relative_save_offset;
8587                         }
8588                         ndr->flags = _flags_save_string;
8589                 }
8590                 {
8591                         uint32_t _flags_save_string = ndr->flags;
8592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8593                         if (r->help_file) {
8594                                 uint32_t _relative_save_offset;
8595                                 _relative_save_offset = ndr->offset;
8596                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
8597                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8598                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8599                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
8600                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8601                                 ndr->offset = _relative_save_offset;
8602                         }
8603                         ndr->flags = _flags_save_string;
8604                 }
8605                 {
8606                         uint32_t _flags_save_string_array = ndr->flags;
8607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8608                         if (r->dependent_files) {
8609                                 uint32_t _relative_save_offset;
8610                                 _relative_save_offset = ndr->offset;
8611                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
8612                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8613                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8614                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
8615                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8616                                 ndr->offset = _relative_save_offset;
8617                         }
8618                         ndr->flags = _flags_save_string_array;
8619                 }
8620                 {
8621                         uint32_t _flags_save_string = ndr->flags;
8622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8623                         if (r->monitor_name) {
8624                                 uint32_t _relative_save_offset;
8625                                 _relative_save_offset = ndr->offset;
8626                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
8627                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8628                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8629                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
8630                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8631                                 ndr->offset = _relative_save_offset;
8632                         }
8633                         ndr->flags = _flags_save_string;
8634                 }
8635                 {
8636                         uint32_t _flags_save_string = ndr->flags;
8637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8638                         if (r->default_datatype) {
8639                                 uint32_t _relative_save_offset;
8640                                 _relative_save_offset = ndr->offset;
8641                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
8642                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8643                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8644                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
8645                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8646                                 ndr->offset = _relative_save_offset;
8647                         }
8648                         ndr->flags = _flags_save_string;
8649                 }
8650                 {
8651                         uint32_t _flags_save_string_array = ndr->flags;
8652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8653                         if (r->previous_names) {
8654                                 uint32_t _relative_save_offset;
8655                                 _relative_save_offset = ndr->offset;
8656                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
8657                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8658                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8659                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
8660                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8661                                 ndr->offset = _relative_save_offset;
8662                         }
8663                         ndr->flags = _flags_save_string_array;
8664                 }
8665                 {
8666                         uint32_t _flags_save_string = ndr->flags;
8667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8668                         if (r->manufacturer_name) {
8669                                 uint32_t _relative_save_offset;
8670                                 _relative_save_offset = ndr->offset;
8671                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
8672                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8673                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8674                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
8675                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8676                                 ndr->offset = _relative_save_offset;
8677                         }
8678                         ndr->flags = _flags_save_string;
8679                 }
8680                 {
8681                         uint32_t _flags_save_string = ndr->flags;
8682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8683                         if (r->manufacturer_url) {
8684                                 uint32_t _relative_save_offset;
8685                                 _relative_save_offset = ndr->offset;
8686                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
8687                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8688                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8689                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
8690                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8691                                 ndr->offset = _relative_save_offset;
8692                         }
8693                         ndr->flags = _flags_save_string;
8694                 }
8695                 {
8696                         uint32_t _flags_save_string = ndr->flags;
8697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8698                         if (r->hardware_id) {
8699                                 uint32_t _relative_save_offset;
8700                                 _relative_save_offset = ndr->offset;
8701                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
8702                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8703                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8704                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
8705                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8706                                 ndr->offset = _relative_save_offset;
8707                         }
8708                         ndr->flags = _flags_save_string;
8709                 }
8710                 {
8711                         uint32_t _flags_save_string = ndr->flags;
8712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8713                         if (r->provider) {
8714                                 uint32_t _relative_save_offset;
8715                                 _relative_save_offset = ndr->offset;
8716                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
8717                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8718                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8719                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
8720                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8721                                 ndr->offset = _relative_save_offset;
8722                         }
8723                         ndr->flags = _flags_save_string;
8724                 }
8725         }
8726         return NDR_ERR_SUCCESS;
8727 }
8728
8729 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
8730 {
8731         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
8732         ndr->depth++;
8733         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8734         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8735         ndr->depth++;
8736         if (r->driver_name) {
8737                 ndr_print_string(ndr, "driver_name", r->driver_name);
8738         }
8739         ndr->depth--;
8740         ndr_print_ptr(ndr, "architecture", r->architecture);
8741         ndr->depth++;
8742         if (r->architecture) {
8743                 ndr_print_string(ndr, "architecture", r->architecture);
8744         }
8745         ndr->depth--;
8746         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8747         ndr->depth++;
8748         if (r->driver_path) {
8749                 ndr_print_string(ndr, "driver_path", r->driver_path);
8750         }
8751         ndr->depth--;
8752         ndr_print_ptr(ndr, "data_file", r->data_file);
8753         ndr->depth++;
8754         if (r->data_file) {
8755                 ndr_print_string(ndr, "data_file", r->data_file);
8756         }
8757         ndr->depth--;
8758         ndr_print_ptr(ndr, "config_file", r->config_file);
8759         ndr->depth++;
8760         if (r->config_file) {
8761                 ndr_print_string(ndr, "config_file", r->config_file);
8762         }
8763         ndr->depth--;
8764         ndr_print_ptr(ndr, "help_file", r->help_file);
8765         ndr->depth++;
8766         if (r->help_file) {
8767                 ndr_print_string(ndr, "help_file", r->help_file);
8768         }
8769         ndr->depth--;
8770         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8771         ndr->depth++;
8772         if (r->dependent_files) {
8773                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
8774         }
8775         ndr->depth--;
8776         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8777         ndr->depth++;
8778         if (r->monitor_name) {
8779                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8783         ndr->depth++;
8784         if (r->default_datatype) {
8785                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8789         ndr->depth++;
8790         if (r->previous_names) {
8791                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
8792         }
8793         ndr->depth--;
8794         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
8795         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8796         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8797         ndr->depth++;
8798         if (r->manufacturer_name) {
8799                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8800         }
8801         ndr->depth--;
8802         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8803         ndr->depth++;
8804         if (r->manufacturer_url) {
8805                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8806         }
8807         ndr->depth--;
8808         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8809         ndr->depth++;
8810         if (r->hardware_id) {
8811                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8812         }
8813         ndr->depth--;
8814         ndr_print_ptr(ndr, "provider", r->provider);
8815         ndr->depth++;
8816         if (r->provider) {
8817                 ndr_print_string(ndr, "provider", r->provider);
8818         }
8819         ndr->depth--;
8820         ndr->depth--;
8821 }
8822
8823 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
8824 {
8825         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
8826         if (ndr_flags & NDR_SCALARS) {
8827                 int level = ndr_push_get_switch_value(ndr, r);
8828                 switch (level) {
8829                         case 1: {
8830                                 NDR_CHECK(ndr_push_align(ndr, 4));
8831                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
8832                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
8833                         break; }
8834
8835                         case 2: {
8836                                 NDR_CHECK(ndr_push_align(ndr, 4));
8837                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
8838                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
8839                         break; }
8840
8841                         case 3: {
8842                                 NDR_CHECK(ndr_push_align(ndr, 4));
8843                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
8844                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
8845                         break; }
8846
8847                         case 4: {
8848                                 NDR_CHECK(ndr_push_align(ndr, 4));
8849                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
8850                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
8851                         break; }
8852
8853                         case 5: {
8854                                 NDR_CHECK(ndr_push_align(ndr, 4));
8855                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
8856                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
8857                         break; }
8858
8859                         case 6: {
8860                                 NDR_CHECK(ndr_push_align(ndr, 8));
8861                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
8862                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
8863                         break; }
8864
8865                         default: {
8866                         break; }
8867
8868                 }
8869         }
8870         if (ndr_flags & NDR_BUFFERS) {
8871                 int level = ndr_push_get_switch_value(ndr, r);
8872                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
8873                 switch (level) {
8874                         case 1:
8875                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
8876                         break;
8877
8878                         case 2:
8879                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
8880                         break;
8881
8882                         case 3:
8883                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
8884                         break;
8885
8886                         case 4:
8887                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
8888                         break;
8889
8890                         case 5:
8891                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
8892                         break;
8893
8894                         case 6:
8895                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
8896                         break;
8897
8898                         default:
8899                         break;
8900
8901                 }
8902         }
8903         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
8904         return NDR_ERR_SUCCESS;
8905 }
8906
8907 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
8908 {
8909         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
8910         int level;
8911         level = ndr_pull_get_switch_value(ndr, r);
8912         if (ndr_flags & NDR_SCALARS) {
8913                 switch (level) {
8914                         case 1: {
8915                                 NDR_CHECK(ndr_pull_align(ndr, 4));
8916                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8917                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
8918                         break; }
8919
8920                         case 2: {
8921                                 NDR_CHECK(ndr_pull_align(ndr, 4));
8922                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8923                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
8924                         break; }
8925
8926                         case 3: {
8927                                 NDR_CHECK(ndr_pull_align(ndr, 4));
8928                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8929                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
8930                         break; }
8931
8932                         case 4: {
8933                                 NDR_CHECK(ndr_pull_align(ndr, 4));
8934                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8935                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
8936                         break; }
8937
8938                         case 5: {
8939                                 NDR_CHECK(ndr_pull_align(ndr, 4));
8940                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8941                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
8942                         break; }
8943
8944                         case 6: {
8945                                 NDR_CHECK(ndr_pull_align(ndr, 8));
8946                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8947                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
8948                         break; }
8949
8950                         default: {
8951                         break; }
8952
8953                 }
8954         }
8955         if (ndr_flags & NDR_BUFFERS) {
8956                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
8957                 switch (level) {
8958                         case 1:
8959                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
8960                         break;
8961
8962                         case 2:
8963                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
8964                         break;
8965
8966                         case 3:
8967                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
8968                         break;
8969
8970                         case 4:
8971                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
8972                         break;
8973
8974                         case 5:
8975                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
8976                         break;
8977
8978                         case 6:
8979                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
8980                         break;
8981
8982                         default:
8983                         break;
8984
8985                 }
8986         }
8987         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
8988         return NDR_ERR_SUCCESS;
8989 }
8990
8991 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
8992 {
8993         int level;
8994         level = ndr_print_get_switch_value(ndr, r);
8995         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
8996         switch (level) {
8997                 case 1:
8998                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
8999                 break;
9000
9001                 case 2:
9002                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
9003                 break;
9004
9005                 case 3:
9006                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
9007                 break;
9008
9009                 case 4:
9010                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
9011                 break;
9012
9013                 case 5:
9014                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
9015                 break;
9016
9017                 case 6:
9018                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
9019                 break;
9020
9021                 default:
9022                 break;
9023
9024         }
9025 }
9026
9027 static enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
9028 {
9029         if (ndr_flags & NDR_SCALARS) {
9030                 NDR_CHECK(ndr_push_align(ndr, 4));
9031                 {
9032                         uint32_t _flags_save_string = ndr->flags;
9033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9034                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
9035                         ndr->flags = _flags_save_string;
9036                 }
9037         }
9038         if (ndr_flags & NDR_BUFFERS) {
9039         }
9040         return NDR_ERR_SUCCESS;
9041 }
9042
9043 static enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
9044 {
9045         if (ndr_flags & NDR_SCALARS) {
9046                 NDR_CHECK(ndr_pull_align(ndr, 4));
9047                 {
9048                         uint32_t _flags_save_string = ndr->flags;
9049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9050                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
9051                         ndr->flags = _flags_save_string;
9052                 }
9053         }
9054         if (ndr_flags & NDR_BUFFERS) {
9055         }
9056         return NDR_ERR_SUCCESS;
9057 }
9058
9059 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
9060 {
9061         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
9062         ndr->depth++;
9063         ndr_print_string(ndr, "directory_name", r->directory_name);
9064         ndr->depth--;
9065 }
9066
9067 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
9068 {
9069         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
9070         if (ndr_flags & NDR_SCALARS) {
9071                 int level = ndr_push_get_switch_value(ndr, r);
9072                 switch (level) {
9073                         case 1: {
9074                                 NDR_CHECK(ndr_push_align(ndr, 4));
9075                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
9076                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
9077                         break; }
9078
9079                         default: {
9080                                 NDR_CHECK(ndr_push_align(ndr, 4));
9081                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
9082                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
9083                         break; }
9084
9085                 }
9086         }
9087         if (ndr_flags & NDR_BUFFERS) {
9088                 int level = ndr_push_get_switch_value(ndr, r);
9089                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
9090                 switch (level) {
9091                         case 1:
9092                         break;
9093
9094                         default:
9095                         break;
9096
9097                 }
9098         }
9099         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
9100         return NDR_ERR_SUCCESS;
9101 }
9102
9103 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
9104 {
9105         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
9106         int level;
9107         level = ndr_pull_get_switch_value(ndr, r);
9108         if (ndr_flags & NDR_SCALARS) {
9109                 switch (level) {
9110                         case 1: {
9111                                 NDR_CHECK(ndr_pull_align(ndr, 4));
9112                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
9113                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
9114                         break; }
9115
9116                         default: {
9117                                 NDR_CHECK(ndr_pull_align(ndr, 4));
9118                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
9119                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
9120                         break; }
9121
9122                 }
9123         }
9124         if (ndr_flags & NDR_BUFFERS) {
9125                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
9126                 switch (level) {
9127                         case 1:
9128                         break;
9129
9130                         default:
9131                         break;
9132
9133                 }
9134         }
9135         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
9136         return NDR_ERR_SUCCESS;
9137 }
9138
9139 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
9140 {
9141         int level;
9142         level = ndr_print_get_switch_value(ndr, r);
9143         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
9144         switch (level) {
9145                 case 1:
9146                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
9147                 break;
9148
9149                 default:
9150                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
9151                 break;
9152
9153         }
9154 }
9155
9156 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
9157 {
9158         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
9159 }
9160
9161 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
9162 {
9163         if (ndr_flags & NDR_SCALARS) {
9164                 NDR_CHECK(ndr_push_align(ndr, 4));
9165                 {
9166                         uint32_t _flags_save_string = ndr->flags;
9167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9168                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
9169                         ndr->flags = _flags_save_string;
9170                 }
9171         }
9172         if (ndr_flags & NDR_BUFFERS) {
9173                 {
9174                         uint32_t _flags_save_string = ndr->flags;
9175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9176                         if (r->print_processor_name) {
9177                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
9178                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
9179                         }
9180                         ndr->flags = _flags_save_string;
9181                 }
9182         }
9183         return NDR_ERR_SUCCESS;
9184 }
9185
9186 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
9187 {
9188         uint32_t _ptr_print_processor_name;
9189         TALLOC_CTX *_mem_save_print_processor_name_0;
9190         if (ndr_flags & NDR_SCALARS) {
9191                 NDR_CHECK(ndr_pull_align(ndr, 4));
9192                 {
9193                         uint32_t _flags_save_string = ndr->flags;
9194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
9196                         if (_ptr_print_processor_name) {
9197                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
9198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
9199                         } else {
9200                                 r->print_processor_name = NULL;
9201                         }
9202                         ndr->flags = _flags_save_string;
9203                 }
9204         }
9205         if (ndr_flags & NDR_BUFFERS) {
9206                 {
9207                         uint32_t _flags_save_string = ndr->flags;
9208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9209                         if (r->print_processor_name) {
9210                                 uint32_t _relative_save_offset;
9211                                 _relative_save_offset = ndr->offset;
9212                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
9213                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9214                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
9215                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
9216                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
9217                                 ndr->offset = _relative_save_offset;
9218                         }
9219                         ndr->flags = _flags_save_string;
9220                 }
9221         }
9222         return NDR_ERR_SUCCESS;
9223 }
9224
9225 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
9226 {
9227         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
9228         ndr->depth++;
9229         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
9230         ndr->depth++;
9231         if (r->print_processor_name) {
9232                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
9233         }
9234         ndr->depth--;
9235         ndr->depth--;
9236 }
9237
9238 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
9239 {
9240         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
9241         if (ndr_flags & NDR_SCALARS) {
9242                 int level = ndr_push_get_switch_value(ndr, r);
9243                 switch (level) {
9244                         case 1: {
9245                                 NDR_CHECK(ndr_push_align(ndr, 4));
9246                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
9247                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
9248                         break; }
9249
9250                         default: {
9251                         break; }
9252
9253                 }
9254         }
9255         if (ndr_flags & NDR_BUFFERS) {
9256                 int level = ndr_push_get_switch_value(ndr, r);
9257                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
9258                 switch (level) {
9259                         case 1:
9260                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
9261                         break;
9262
9263                         default:
9264                         break;
9265
9266                 }
9267         }
9268         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
9269         return NDR_ERR_SUCCESS;
9270 }
9271
9272 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
9273 {
9274         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
9275         int level;
9276         level = ndr_pull_get_switch_value(ndr, r);
9277         if (ndr_flags & NDR_SCALARS) {
9278                 switch (level) {
9279                         case 1: {
9280                                 NDR_CHECK(ndr_pull_align(ndr, 4));
9281                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
9282                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
9283                         break; }
9284
9285                         default: {
9286                         break; }
9287
9288                 }
9289         }
9290         if (ndr_flags & NDR_BUFFERS) {
9291                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
9292                 switch (level) {
9293                         case 1:
9294                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
9295                         break;
9296
9297                         default:
9298                         break;
9299
9300                 }
9301         }
9302         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
9303         return NDR_ERR_SUCCESS;
9304 }
9305
9306 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
9307 {
9308         int level;
9309         level = ndr_print_get_switch_value(ndr, r);
9310         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
9311         switch (level) {
9312                 case 1:
9313                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
9314                 break;
9315
9316                 default:
9317                 break;
9318
9319         }
9320 }
9321
9322 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
9323 {
9324         if (ndr_flags & NDR_SCALARS) {
9325                 NDR_CHECK(ndr_push_align(ndr, 4));
9326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
9327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
9328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
9329         }
9330         if (ndr_flags & NDR_BUFFERS) {
9331                 if (r->document_name) {
9332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
9333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
9335                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9336                 }
9337                 if (r->output_file) {
9338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
9339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
9341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9342                 }
9343                 if (r->datatype) {
9344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
9345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
9347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9348                 }
9349         }
9350         return NDR_ERR_SUCCESS;
9351 }
9352
9353 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
9354 {
9355         uint32_t _ptr_document_name;
9356         TALLOC_CTX *_mem_save_document_name_0;
9357         uint32_t _ptr_output_file;
9358         TALLOC_CTX *_mem_save_output_file_0;
9359         uint32_t _ptr_datatype;
9360         TALLOC_CTX *_mem_save_datatype_0;
9361         if (ndr_flags & NDR_SCALARS) {
9362                 NDR_CHECK(ndr_pull_align(ndr, 4));
9363                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
9364                 if (_ptr_document_name) {
9365                         NDR_PULL_ALLOC(ndr, r->document_name);
9366                 } else {
9367                         r->document_name = NULL;
9368                 }
9369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
9370                 if (_ptr_output_file) {
9371                         NDR_PULL_ALLOC(ndr, r->output_file);
9372                 } else {
9373                         r->output_file = NULL;
9374                 }
9375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
9376                 if (_ptr_datatype) {
9377                         NDR_PULL_ALLOC(ndr, r->datatype);
9378                 } else {
9379                         r->datatype = NULL;
9380                 }
9381         }
9382         if (ndr_flags & NDR_BUFFERS) {
9383                 if (r->document_name) {
9384                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9385                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
9386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
9387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
9388                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
9389                                 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));
9390                         }
9391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
9392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
9393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
9394                 }
9395                 if (r->output_file) {
9396                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9397                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
9398                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
9399                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
9400                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
9401                                 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));
9402                         }
9403                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
9404                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
9405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
9406                 }
9407                 if (r->datatype) {
9408                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9409                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
9410                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
9411                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
9412                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
9413                                 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));
9414                         }
9415                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
9416                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
9417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
9418                 }
9419         }
9420         return NDR_ERR_SUCCESS;
9421 }
9422
9423 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
9424 {
9425         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
9426         ndr->depth++;
9427         ndr_print_ptr(ndr, "document_name", r->document_name);
9428         ndr->depth++;
9429         if (r->document_name) {
9430                 ndr_print_string(ndr, "document_name", r->document_name);
9431         }
9432         ndr->depth--;
9433         ndr_print_ptr(ndr, "output_file", r->output_file);
9434         ndr->depth++;
9435         if (r->output_file) {
9436                 ndr_print_string(ndr, "output_file", r->output_file);
9437         }
9438         ndr->depth--;
9439         ndr_print_ptr(ndr, "datatype", r->datatype);
9440         ndr->depth++;
9441         if (r->datatype) {
9442                 ndr_print_string(ndr, "datatype", r->datatype);
9443         }
9444         ndr->depth--;
9445         ndr->depth--;
9446 }
9447
9448 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
9449 {
9450         if (ndr_flags & NDR_SCALARS) {
9451                 int level = ndr_push_get_switch_value(ndr, r);
9452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9453                 switch (level) {
9454                         case 1: {
9455                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9456                         break; }
9457
9458                         case 2: {
9459                         break; }
9460
9461                         case 3: {
9462                         break; }
9463
9464                         default: {
9465                         break; }
9466
9467                 }
9468         }
9469         if (ndr_flags & NDR_BUFFERS) {
9470                 int level = ndr_push_get_switch_value(ndr, r);
9471                 switch (level) {
9472                         case 1:
9473                                 if (r->info1) {
9474                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9475                                 }
9476                         break;
9477
9478                         case 2:
9479                         break;
9480
9481                         case 3:
9482                         break;
9483
9484                         default:
9485                         break;
9486
9487                 }
9488         }
9489         return NDR_ERR_SUCCESS;
9490 }
9491
9492 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
9493 {
9494         int level;
9495         uint32_t _level;
9496         TALLOC_CTX *_mem_save_info1_0;
9497         level = ndr_pull_get_switch_value(ndr, r);
9498         if (ndr_flags & NDR_SCALARS) {
9499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9500                 if (_level != level) {
9501                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9502                 }
9503                 switch (level) {
9504                         case 1: {
9505                                 uint32_t _ptr_info1;
9506                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9507                                 if (_ptr_info1) {
9508                                         NDR_PULL_ALLOC(ndr, r->info1);
9509                                 } else {
9510                                         r->info1 = NULL;
9511                                 }
9512                         break; }
9513
9514                         case 2: {
9515                         break; }
9516
9517                         case 3: {
9518                         break; }
9519
9520                         default: {
9521                         break; }
9522
9523                 }
9524         }
9525         if (ndr_flags & NDR_BUFFERS) {
9526                 switch (level) {
9527                         case 1:
9528                                 if (r->info1) {
9529                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9530                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9531                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9532                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9533                                 }
9534                         break;
9535
9536                         case 2:
9537                         break;
9538
9539                         case 3:
9540                         break;
9541
9542                         default:
9543                         break;
9544
9545                 }
9546         }
9547         return NDR_ERR_SUCCESS;
9548 }
9549
9550 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
9551 {
9552         int level;
9553         level = ndr_print_get_switch_value(ndr, r);
9554         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
9555         switch (level) {
9556                 case 1:
9557                         ndr_print_ptr(ndr, "info1", r->info1);
9558                         ndr->depth++;
9559                         if (r->info1) {
9560                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
9561                         }
9562                         ndr->depth--;
9563                 break;
9564
9565                 case 2:
9566                 break;
9567
9568                 case 3:
9569                 break;
9570
9571                 default:
9572                 break;
9573
9574         }
9575 }
9576
9577 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
9578 {
9579         if (ndr_flags & NDR_SCALARS) {
9580                 NDR_CHECK(ndr_push_align(ndr, 4));
9581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
9582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
9583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
9584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
9585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
9586                 {
9587                         uint32_t _flags_save_string = ndr->flags;
9588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9589                         {
9590                                 struct ndr_push *_ndr_extra_string;
9591                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
9592                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
9593                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
9594                         }
9595                         ndr->flags = _flags_save_string;
9596                 }
9597         }
9598         if (ndr_flags & NDR_BUFFERS) {
9599         }
9600         return NDR_ERR_SUCCESS;
9601 }
9602
9603 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
9604 {
9605         if (ndr_flags & NDR_SCALARS) {
9606                 NDR_CHECK(ndr_pull_align(ndr, 4));
9607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
9608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
9609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
9610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
9611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
9612                 {
9613                         uint32_t _flags_save_string = ndr->flags;
9614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9615                         {
9616                                 struct ndr_pull *_ndr_extra_string;
9617                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
9618                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
9619                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
9620                         }
9621                         ndr->flags = _flags_save_string;
9622                 }
9623         }
9624         if (ndr_flags & NDR_BUFFERS) {
9625         }
9626         return NDR_ERR_SUCCESS;
9627 }
9628
9629 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
9630 {
9631         ndr_print_struct(ndr, name, "spoolss_OSVersion");
9632         ndr->depth++;
9633         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);
9634         ndr_print_uint32(ndr, "major", r->major);
9635         ndr_print_uint32(ndr, "minor", r->minor);
9636         ndr_print_uint32(ndr, "build", r->build);
9637         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
9638         ndr_print_string(ndr, "extra_string", r->extra_string);
9639         ndr->depth--;
9640 }
9641
9642 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
9643 {
9644         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
9645 }
9646
9647 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
9648 {
9649         if (ndr_flags & NDR_SCALARS) {
9650                 NDR_CHECK(ndr_push_align(ndr, 4));
9651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
9652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
9653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
9654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
9655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
9656                 {
9657                         uint32_t _flags_save_string = ndr->flags;
9658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9659                         {
9660                                 struct ndr_push *_ndr_extra_string;
9661                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
9662                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
9663                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
9664                         }
9665                         ndr->flags = _flags_save_string;
9666                 }
9667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
9669         }
9670         if (ndr_flags & NDR_BUFFERS) {
9671         }
9672         return NDR_ERR_SUCCESS;
9673 }
9674
9675 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
9676 {
9677         if (ndr_flags & NDR_SCALARS) {
9678                 NDR_CHECK(ndr_pull_align(ndr, 4));
9679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
9680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
9681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
9682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
9683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9684                 {
9685                         uint32_t _flags_save_string = ndr->flags;
9686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9687                         {
9688                                 struct ndr_pull *_ndr_extra_string;
9689                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
9690                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
9691                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
9692                         }
9693                         ndr->flags = _flags_save_string;
9694                 }
9695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
9697         }
9698         if (ndr_flags & NDR_BUFFERS) {
9699         }
9700         return NDR_ERR_SUCCESS;
9701 }
9702
9703 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
9704 {
9705         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
9706         ndr->depth++;
9707         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);
9708         ndr_print_uint32(ndr, "major", r->major);
9709         ndr_print_uint32(ndr, "minor", r->minor);
9710         ndr_print_uint32(ndr, "build", r->build);
9711         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
9712         ndr_print_string(ndr, "extra_string", r->extra_string);
9713         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9714         ndr_print_uint32(ndr, "unknown3", r->unknown3);
9715         ndr->depth--;
9716 }
9717
9718 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
9719 {
9720         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
9721 }
9722
9723 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
9724 {
9725         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9726         return NDR_ERR_SUCCESS;
9727 }
9728
9729 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
9730 {
9731         uint32_t v;
9732         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9733         *r = v;
9734         return NDR_ERR_SUCCESS;
9735 }
9736
9737 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
9738 {
9739         const char *val = NULL;
9740
9741         switch (r) {
9742                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
9743                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
9744                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
9745                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
9746                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
9747         }
9748         ndr_print_enum(ndr, name, "ENUM", val, r);
9749 }
9750
9751 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
9752 {
9753         if (ndr_flags & NDR_SCALARS) {
9754                 int level = ndr_push_get_switch_value(ndr, r);
9755                 switch (level) {
9756                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
9757                         break; }
9758
9759                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
9760                                 {
9761                                         uint32_t _flags_save_string = ndr->flags;
9762                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9763                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
9764                                         ndr->flags = _flags_save_string;
9765                                 }
9766                         break; }
9767
9768                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
9769                                 {
9770                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
9771                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
9772                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
9773                                         ndr->flags = _flags_save_DATA_BLOB;
9774                                 }
9775                         break; }
9776
9777                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
9778                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
9779                         break; }
9780
9781                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
9782                                 {
9783                                         uint32_t _flags_save_string_array = ndr->flags;
9784                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9785                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
9786                                         ndr->flags = _flags_save_string_array;
9787                                 }
9788                         break; }
9789
9790                         default: {
9791                                 {
9792                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
9793                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
9794                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
9795                                         ndr->flags = _flags_save_DATA_BLOB;
9796                                 }
9797                         break; }
9798
9799                 }
9800         }
9801         if (ndr_flags & NDR_BUFFERS) {
9802                 int level = ndr_push_get_switch_value(ndr, r);
9803                 switch (level) {
9804                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
9805                         break;
9806
9807                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
9808                         break;
9809
9810                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
9811                         break;
9812
9813                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
9814                         break;
9815
9816                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
9817                         break;
9818
9819                         default:
9820                         break;
9821
9822                 }
9823         }
9824         return NDR_ERR_SUCCESS;
9825 }
9826
9827 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
9828 {
9829         int level;
9830         level = ndr_pull_get_switch_value(ndr, r);
9831         if (ndr_flags & NDR_SCALARS) {
9832                 switch (level) {
9833                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
9834                         break; }
9835
9836                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
9837                                 {
9838                                         uint32_t _flags_save_string = ndr->flags;
9839                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9840                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
9841                                         ndr->flags = _flags_save_string;
9842                                 }
9843                         break; }
9844
9845                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
9846                                 {
9847                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
9848                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
9849                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
9850                                         ndr->flags = _flags_save_DATA_BLOB;
9851                                 }
9852                         break; }
9853
9854                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
9855                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
9856                         break; }
9857
9858                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
9859                                 {
9860                                         uint32_t _flags_save_string_array = ndr->flags;
9861                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9862                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
9863                                         ndr->flags = _flags_save_string_array;
9864                                 }
9865                         break; }
9866
9867                         default: {
9868                                 {
9869                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
9870                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
9871                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
9872                                         ndr->flags = _flags_save_DATA_BLOB;
9873                                 }
9874                         break; }
9875
9876                 }
9877         }
9878         if (ndr_flags & NDR_BUFFERS) {
9879                 switch (level) {
9880                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
9881                         break;
9882
9883                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
9884                         break;
9885
9886                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
9887                         break;
9888
9889                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
9890                         break;
9891
9892                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
9893                         break;
9894
9895                         default:
9896                         break;
9897
9898                 }
9899         }
9900         return NDR_ERR_SUCCESS;
9901 }
9902
9903 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
9904 {
9905         int level;
9906         level = ndr_print_get_switch_value(ndr, r);
9907         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
9908         switch (level) {
9909                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
9910                 break;
9911
9912                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
9913                         ndr_print_string(ndr, "string", r->string);
9914                 break;
9915
9916                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
9917                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
9918                 break;
9919
9920                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
9921                         ndr_print_uint32(ndr, "value", r->value);
9922                 break;
9923
9924                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
9925                         ndr_print_string_array(ndr, "string_array", r->string_array);
9926                 break;
9927
9928                 default:
9929                         ndr_print_DATA_BLOB(ndr, "data", r->data);
9930                 break;
9931
9932         }
9933 }
9934
9935 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
9936 {
9937         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
9938 }
9939
9940 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
9941 {
9942         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9943         return NDR_ERR_SUCCESS;
9944 }
9945
9946 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
9947 {
9948         uint32_t v;
9949         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9950         *r = v;
9951         return NDR_ERR_SUCCESS;
9952 }
9953
9954 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
9955 {
9956         const char *val = NULL;
9957
9958         switch (r) {
9959                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
9960                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
9961                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
9962         }
9963         ndr_print_enum(ndr, name, "ENUM", val, r);
9964 }
9965
9966 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
9967 {
9968         if (ndr_flags & NDR_SCALARS) {
9969                 NDR_CHECK(ndr_push_align(ndr, 4));
9970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
9971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
9972         }
9973         if (ndr_flags & NDR_BUFFERS) {
9974         }
9975         return NDR_ERR_SUCCESS;
9976 }
9977
9978 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
9979 {
9980         if (ndr_flags & NDR_SCALARS) {
9981                 NDR_CHECK(ndr_pull_align(ndr, 4));
9982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
9983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
9984         }
9985         if (ndr_flags & NDR_BUFFERS) {
9986         }
9987         return NDR_ERR_SUCCESS;
9988 }
9989
9990 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
9991 {
9992         ndr_print_struct(ndr, name, "spoolss_FormSize");
9993         ndr->depth++;
9994         ndr_print_uint32(ndr, "width", r->width);
9995         ndr_print_uint32(ndr, "height", r->height);
9996         ndr->depth--;
9997 }
9998
9999 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
10000 {
10001         if (ndr_flags & NDR_SCALARS) {
10002                 NDR_CHECK(ndr_push_align(ndr, 4));
10003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
10004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
10005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
10006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
10007         }
10008         if (ndr_flags & NDR_BUFFERS) {
10009         }
10010         return NDR_ERR_SUCCESS;
10011 }
10012
10013 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
10014 {
10015         if (ndr_flags & NDR_SCALARS) {
10016                 NDR_CHECK(ndr_pull_align(ndr, 4));
10017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
10018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
10019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
10020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
10021         }
10022         if (ndr_flags & NDR_BUFFERS) {
10023         }
10024         return NDR_ERR_SUCCESS;
10025 }
10026
10027 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
10028 {
10029         ndr_print_struct(ndr, name, "spoolss_FormArea");
10030         ndr->depth++;
10031         ndr_print_uint32(ndr, "left", r->left);
10032         ndr_print_uint32(ndr, "top", r->top);
10033         ndr_print_uint32(ndr, "right", r->right);
10034         ndr_print_uint32(ndr, "bottom", r->bottom);
10035         ndr->depth--;
10036 }
10037
10038 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
10039 {
10040         if (ndr_flags & NDR_SCALARS) {
10041                 NDR_CHECK(ndr_push_align(ndr, 4));
10042                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
10043                 {
10044                         uint32_t _flags_save_string = ndr->flags;
10045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10046                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
10047                         ndr->flags = _flags_save_string;
10048                 }
10049                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
10050                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
10051         }
10052         if (ndr_flags & NDR_BUFFERS) {
10053                 {
10054                         uint32_t _flags_save_string = ndr->flags;
10055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10056                         if (r->form_name) {
10057                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
10058                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
10059                         }
10060                         ndr->flags = _flags_save_string;
10061                 }
10062         }
10063         return NDR_ERR_SUCCESS;
10064 }
10065
10066 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
10067 {
10068         uint32_t _ptr_form_name;
10069         TALLOC_CTX *_mem_save_form_name_0;
10070         if (ndr_flags & NDR_SCALARS) {
10071                 NDR_CHECK(ndr_pull_align(ndr, 4));
10072                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
10073                 {
10074                         uint32_t _flags_save_string = ndr->flags;
10075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10076                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
10077                         if (_ptr_form_name) {
10078                                 NDR_PULL_ALLOC(ndr, r->form_name);
10079                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
10080                         } else {
10081                                 r->form_name = NULL;
10082                         }
10083                         ndr->flags = _flags_save_string;
10084                 }
10085                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
10086                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
10087         }
10088         if (ndr_flags & NDR_BUFFERS) {
10089                 {
10090                         uint32_t _flags_save_string = ndr->flags;
10091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10092                         if (r->form_name) {
10093                                 uint32_t _relative_save_offset;
10094                                 _relative_save_offset = ndr->offset;
10095                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
10096                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10097                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
10098                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
10099                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
10100                                 ndr->offset = _relative_save_offset;
10101                         }
10102                         ndr->flags = _flags_save_string;
10103                 }
10104         }
10105         return NDR_ERR_SUCCESS;
10106 }
10107
10108 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
10109 {
10110         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
10111         ndr->depth++;
10112         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
10113         ndr_print_ptr(ndr, "form_name", r->form_name);
10114         ndr->depth++;
10115         if (r->form_name) {
10116                 ndr_print_string(ndr, "form_name", r->form_name);
10117         }
10118         ndr->depth--;
10119         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
10120         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
10121         ndr->depth--;
10122 }
10123
10124 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
10125 {
10126         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10127         if (ndr_flags & NDR_SCALARS) {
10128                 int level = ndr_push_get_switch_value(ndr, r);
10129                 switch (level) {
10130                         case 1: {
10131                                 NDR_CHECK(ndr_push_align(ndr, 4));
10132                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10133                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
10134                         break; }
10135
10136                         default: {
10137                         break; }
10138
10139                 }
10140         }
10141         if (ndr_flags & NDR_BUFFERS) {
10142                 int level = ndr_push_get_switch_value(ndr, r);
10143                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10144                 switch (level) {
10145                         case 1:
10146                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
10147                         break;
10148
10149                         default:
10150                         break;
10151
10152                 }
10153         }
10154         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10155         return NDR_ERR_SUCCESS;
10156 }
10157
10158 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
10159 {
10160         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10161         int level;
10162         level = ndr_pull_get_switch_value(ndr, r);
10163         if (ndr_flags & NDR_SCALARS) {
10164                 switch (level) {
10165                         case 1: {
10166                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10167                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10168                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
10169                         break; }
10170
10171                         default: {
10172                         break; }
10173
10174                 }
10175         }
10176         if (ndr_flags & NDR_BUFFERS) {
10177                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10178                 switch (level) {
10179                         case 1:
10180                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
10181                         break;
10182
10183                         default:
10184                         break;
10185
10186                 }
10187         }
10188         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10189         return NDR_ERR_SUCCESS;
10190 }
10191
10192 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
10193 {
10194         int level;
10195         level = ndr_print_get_switch_value(ndr, r);
10196         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
10197         switch (level) {
10198                 case 1:
10199                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
10200                 break;
10201
10202                 default:
10203                 break;
10204
10205         }
10206 }
10207
10208 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
10209 {
10210         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
10211 }
10212
10213 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
10214 {
10215         if (ndr_flags & NDR_SCALARS) {
10216                 NDR_CHECK(ndr_push_align(ndr, 4));
10217                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
10218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
10219                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
10220                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
10221         }
10222         if (ndr_flags & NDR_BUFFERS) {
10223                 if (r->form_name) {
10224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
10225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
10227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10228                 }
10229         }
10230         return NDR_ERR_SUCCESS;
10231 }
10232
10233 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
10234 {
10235         uint32_t _ptr_form_name;
10236         TALLOC_CTX *_mem_save_form_name_0;
10237         if (ndr_flags & NDR_SCALARS) {
10238                 NDR_CHECK(ndr_pull_align(ndr, 4));
10239                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
10240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
10241                 if (_ptr_form_name) {
10242                         NDR_PULL_ALLOC(ndr, r->form_name);
10243                 } else {
10244                         r->form_name = NULL;
10245                 }
10246                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
10247                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
10248         }
10249         if (ndr_flags & NDR_BUFFERS) {
10250                 if (r->form_name) {
10251                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10252                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
10253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
10254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
10255                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
10256                                 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));
10257                         }
10258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
10259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
10260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
10261                 }
10262         }
10263         return NDR_ERR_SUCCESS;
10264 }
10265
10266 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
10267 {
10268         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
10269         ndr->depth++;
10270         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
10271         ndr_print_ptr(ndr, "form_name", r->form_name);
10272         ndr->depth++;
10273         if (r->form_name) {
10274                 ndr_print_string(ndr, "form_name", r->form_name);
10275         }
10276         ndr->depth--;
10277         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
10278         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
10279         ndr->depth--;
10280 }
10281
10282 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
10283 {
10284         if (ndr_flags & NDR_SCALARS) {
10285                 int level = ndr_push_get_switch_value(ndr, r);
10286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10287                 switch (level) {
10288                         case 1: {
10289                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10290                         break; }
10291
10292                         default:
10293                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10294                 }
10295         }
10296         if (ndr_flags & NDR_BUFFERS) {
10297                 int level = ndr_push_get_switch_value(ndr, r);
10298                 switch (level) {
10299                         case 1:
10300                                 if (r->info1) {
10301                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10302                                 }
10303                         break;
10304
10305                         default:
10306                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10307                 }
10308         }
10309         return NDR_ERR_SUCCESS;
10310 }
10311
10312 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
10313 {
10314         int level;
10315         uint32_t _level;
10316         TALLOC_CTX *_mem_save_info1_0;
10317         level = ndr_pull_get_switch_value(ndr, r);
10318         if (ndr_flags & NDR_SCALARS) {
10319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10320                 if (_level != level) {
10321                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
10322                 }
10323                 switch (level) {
10324                         case 1: {
10325                                 uint32_t _ptr_info1;
10326                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10327                                 if (_ptr_info1) {
10328                                         NDR_PULL_ALLOC(ndr, r->info1);
10329                                 } else {
10330                                         r->info1 = NULL;
10331                                 }
10332                         break; }
10333
10334                         default:
10335                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10336                 }
10337         }
10338         if (ndr_flags & NDR_BUFFERS) {
10339                 switch (level) {
10340                         case 1:
10341                                 if (r->info1) {
10342                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10343                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10344                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10345                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10346                                 }
10347                         break;
10348
10349                         default:
10350                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10351                 }
10352         }
10353         return NDR_ERR_SUCCESS;
10354 }
10355
10356 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
10357 {
10358         int level;
10359         level = ndr_print_get_switch_value(ndr, r);
10360         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
10361         switch (level) {
10362                 case 1:
10363                         ndr_print_ptr(ndr, "info1", r->info1);
10364                         ndr->depth++;
10365                         if (r->info1) {
10366                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
10367                         }
10368                         ndr->depth--;
10369                 break;
10370
10371                 default:
10372                         ndr_print_bad_level(ndr, name, level);
10373         }
10374 }
10375
10376 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
10377 {
10378         if (ndr_flags & NDR_SCALARS) {
10379                 NDR_CHECK(ndr_push_align(ndr, 4));
10380                 {
10381                         uint32_t _flags_save_string = ndr->flags;
10382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10383                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
10384                         ndr->flags = _flags_save_string;
10385                 }
10386         }
10387         if (ndr_flags & NDR_BUFFERS) {
10388                 {
10389                         uint32_t _flags_save_string = ndr->flags;
10390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10391                         if (r->port_name) {
10392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
10393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
10394                         }
10395                         ndr->flags = _flags_save_string;
10396                 }
10397         }
10398         return NDR_ERR_SUCCESS;
10399 }
10400
10401 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
10402 {
10403         uint32_t _ptr_port_name;
10404         TALLOC_CTX *_mem_save_port_name_0;
10405         if (ndr_flags & NDR_SCALARS) {
10406                 NDR_CHECK(ndr_pull_align(ndr, 4));
10407                 {
10408                         uint32_t _flags_save_string = ndr->flags;
10409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10410                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
10411                         if (_ptr_port_name) {
10412                                 NDR_PULL_ALLOC(ndr, r->port_name);
10413                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
10414                         } else {
10415                                 r->port_name = NULL;
10416                         }
10417                         ndr->flags = _flags_save_string;
10418                 }
10419         }
10420         if (ndr_flags & NDR_BUFFERS) {
10421                 {
10422                         uint32_t _flags_save_string = ndr->flags;
10423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10424                         if (r->port_name) {
10425                                 uint32_t _relative_save_offset;
10426                                 _relative_save_offset = ndr->offset;
10427                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
10428                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10429                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
10430                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
10431                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
10432                                 ndr->offset = _relative_save_offset;
10433                         }
10434                         ndr->flags = _flags_save_string;
10435                 }
10436         }
10437         return NDR_ERR_SUCCESS;
10438 }
10439
10440 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
10441 {
10442         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
10443         ndr->depth++;
10444         ndr_print_ptr(ndr, "port_name", r->port_name);
10445         ndr->depth++;
10446         if (r->port_name) {
10447                 ndr_print_string(ndr, "port_name", r->port_name);
10448         }
10449         ndr->depth--;
10450         ndr->depth--;
10451 }
10452
10453 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
10454 {
10455         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
10456         return NDR_ERR_SUCCESS;
10457 }
10458
10459 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
10460 {
10461         uint32_t v;
10462         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
10463         *r = v;
10464         return NDR_ERR_SUCCESS;
10465 }
10466
10467 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
10468 {
10469         ndr_print_uint32(ndr, name, r);
10470         ndr->depth++;
10471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
10472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
10473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
10474         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
10475         ndr->depth--;
10476 }
10477
10478 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
10479 {
10480         if (ndr_flags & NDR_SCALARS) {
10481                 NDR_CHECK(ndr_push_align(ndr, 4));
10482                 {
10483                         uint32_t _flags_save_string = ndr->flags;
10484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10485                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
10486                         ndr->flags = _flags_save_string;
10487                 }
10488                 {
10489                         uint32_t _flags_save_string = ndr->flags;
10490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10491                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10492                         ndr->flags = _flags_save_string;
10493                 }
10494                 {
10495                         uint32_t _flags_save_string = ndr->flags;
10496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10497                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
10498                         ndr->flags = _flags_save_string;
10499                 }
10500                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
10501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10502         }
10503         if (ndr_flags & NDR_BUFFERS) {
10504                 {
10505                         uint32_t _flags_save_string = ndr->flags;
10506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10507                         if (r->port_name) {
10508                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
10509                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
10510                         }
10511                         ndr->flags = _flags_save_string;
10512                 }
10513                 {
10514                         uint32_t _flags_save_string = ndr->flags;
10515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10516                         if (r->monitor_name) {
10517                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10518                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10519                         }
10520                         ndr->flags = _flags_save_string;
10521                 }
10522                 {
10523                         uint32_t _flags_save_string = ndr->flags;
10524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10525                         if (r->description) {
10526                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
10527                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
10528                         }
10529                         ndr->flags = _flags_save_string;
10530                 }
10531         }
10532         return NDR_ERR_SUCCESS;
10533 }
10534
10535 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
10536 {
10537         uint32_t _ptr_port_name;
10538         TALLOC_CTX *_mem_save_port_name_0;
10539         uint32_t _ptr_monitor_name;
10540         TALLOC_CTX *_mem_save_monitor_name_0;
10541         uint32_t _ptr_description;
10542         TALLOC_CTX *_mem_save_description_0;
10543         if (ndr_flags & NDR_SCALARS) {
10544                 NDR_CHECK(ndr_pull_align(ndr, 4));
10545                 {
10546                         uint32_t _flags_save_string = ndr->flags;
10547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10548                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
10549                         if (_ptr_port_name) {
10550                                 NDR_PULL_ALLOC(ndr, r->port_name);
10551                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
10552                         } else {
10553                                 r->port_name = NULL;
10554                         }
10555                         ndr->flags = _flags_save_string;
10556                 }
10557                 {
10558                         uint32_t _flags_save_string = ndr->flags;
10559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10560                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10561                         if (_ptr_monitor_name) {
10562                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10563                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10564                         } else {
10565                                 r->monitor_name = NULL;
10566                         }
10567                         ndr->flags = _flags_save_string;
10568                 }
10569                 {
10570                         uint32_t _flags_save_string = ndr->flags;
10571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10572                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
10573                         if (_ptr_description) {
10574                                 NDR_PULL_ALLOC(ndr, r->description);
10575                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
10576                         } else {
10577                                 r->description = NULL;
10578                         }
10579                         ndr->flags = _flags_save_string;
10580                 }
10581                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
10582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10583         }
10584         if (ndr_flags & NDR_BUFFERS) {
10585                 {
10586                         uint32_t _flags_save_string = ndr->flags;
10587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10588                         if (r->port_name) {
10589                                 uint32_t _relative_save_offset;
10590                                 _relative_save_offset = ndr->offset;
10591                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
10592                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10593                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
10594                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
10595                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
10596                                 ndr->offset = _relative_save_offset;
10597                         }
10598                         ndr->flags = _flags_save_string;
10599                 }
10600                 {
10601                         uint32_t _flags_save_string = ndr->flags;
10602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10603                         if (r->monitor_name) {
10604                                 uint32_t _relative_save_offset;
10605                                 _relative_save_offset = ndr->offset;
10606                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10607                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10608                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10609                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10610                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10611                                 ndr->offset = _relative_save_offset;
10612                         }
10613                         ndr->flags = _flags_save_string;
10614                 }
10615                 {
10616                         uint32_t _flags_save_string = ndr->flags;
10617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10618                         if (r->description) {
10619                                 uint32_t _relative_save_offset;
10620                                 _relative_save_offset = ndr->offset;
10621                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
10622                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
10623                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
10624                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
10625                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
10626                                 ndr->offset = _relative_save_offset;
10627                         }
10628                         ndr->flags = _flags_save_string;
10629                 }
10630         }
10631         return NDR_ERR_SUCCESS;
10632 }
10633
10634 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
10635 {
10636         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
10637         ndr->depth++;
10638         ndr_print_ptr(ndr, "port_name", r->port_name);
10639         ndr->depth++;
10640         if (r->port_name) {
10641                 ndr_print_string(ndr, "port_name", r->port_name);
10642         }
10643         ndr->depth--;
10644         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10645         ndr->depth++;
10646         if (r->monitor_name) {
10647                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10648         }
10649         ndr->depth--;
10650         ndr_print_ptr(ndr, "description", r->description);
10651         ndr->depth++;
10652         if (r->description) {
10653                 ndr_print_string(ndr, "description", r->description);
10654         }
10655         ndr->depth--;
10656         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
10657         ndr_print_uint32(ndr, "reserved", r->reserved);
10658         ndr->depth--;
10659 }
10660
10661 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
10662 {
10663         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10664         if (ndr_flags & NDR_SCALARS) {
10665                 int level = ndr_push_get_switch_value(ndr, r);
10666                 switch (level) {
10667                         case 1: {
10668                                 NDR_CHECK(ndr_push_align(ndr, 4));
10669                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10670                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
10671                         break; }
10672
10673                         case 2: {
10674                                 NDR_CHECK(ndr_push_align(ndr, 4));
10675                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10676                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
10677                         break; }
10678
10679                         case 3: {
10680                         break; }
10681
10682                         default: {
10683                         break; }
10684
10685                 }
10686         }
10687         if (ndr_flags & NDR_BUFFERS) {
10688                 int level = ndr_push_get_switch_value(ndr, r);
10689                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10690                 switch (level) {
10691                         case 1:
10692                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
10693                         break;
10694
10695                         case 2:
10696                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
10697                         break;
10698
10699                         case 3:
10700                         break;
10701
10702                         default:
10703                         break;
10704
10705                 }
10706         }
10707         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10708         return NDR_ERR_SUCCESS;
10709 }
10710
10711 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
10712 {
10713         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10714         int level;
10715         level = ndr_pull_get_switch_value(ndr, r);
10716         if (ndr_flags & NDR_SCALARS) {
10717                 switch (level) {
10718                         case 1: {
10719                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10720                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10721                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
10722                         break; }
10723
10724                         case 2: {
10725                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10726                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10727                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
10728                         break; }
10729
10730                         case 3: {
10731                         break; }
10732
10733                         default: {
10734                         break; }
10735
10736                 }
10737         }
10738         if (ndr_flags & NDR_BUFFERS) {
10739                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10740                 switch (level) {
10741                         case 1:
10742                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
10743                         break;
10744
10745                         case 2:
10746                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
10747                         break;
10748
10749                         case 3:
10750                         break;
10751
10752                         default:
10753                         break;
10754
10755                 }
10756         }
10757         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10758         return NDR_ERR_SUCCESS;
10759 }
10760
10761 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
10762 {
10763         int level;
10764         level = ndr_print_get_switch_value(ndr, r);
10765         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
10766         switch (level) {
10767                 case 1:
10768                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
10769                 break;
10770
10771                 case 2:
10772                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
10773                 break;
10774
10775                 case 3:
10776                 break;
10777
10778                 default:
10779                 break;
10780
10781         }
10782 }
10783
10784 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
10785 {
10786         if (ndr_flags & NDR_SCALARS) {
10787                 NDR_CHECK(ndr_push_align(ndr, 4));
10788                 {
10789                         uint32_t _flags_save_string = ndr->flags;
10790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10791                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10792                         ndr->flags = _flags_save_string;
10793                 }
10794         }
10795         if (ndr_flags & NDR_BUFFERS) {
10796                 {
10797                         uint32_t _flags_save_string = ndr->flags;
10798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10799                         if (r->monitor_name) {
10800                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10801                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10802                         }
10803                         ndr->flags = _flags_save_string;
10804                 }
10805         }
10806         return NDR_ERR_SUCCESS;
10807 }
10808
10809 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
10810 {
10811         uint32_t _ptr_monitor_name;
10812         TALLOC_CTX *_mem_save_monitor_name_0;
10813         if (ndr_flags & NDR_SCALARS) {
10814                 NDR_CHECK(ndr_pull_align(ndr, 4));
10815                 {
10816                         uint32_t _flags_save_string = ndr->flags;
10817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10818                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10819                         if (_ptr_monitor_name) {
10820                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10821                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10822                         } else {
10823                                 r->monitor_name = NULL;
10824                         }
10825                         ndr->flags = _flags_save_string;
10826                 }
10827         }
10828         if (ndr_flags & NDR_BUFFERS) {
10829                 {
10830                         uint32_t _flags_save_string = ndr->flags;
10831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10832                         if (r->monitor_name) {
10833                                 uint32_t _relative_save_offset;
10834                                 _relative_save_offset = ndr->offset;
10835                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10836                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10837                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10838                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10839                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10840                                 ndr->offset = _relative_save_offset;
10841                         }
10842                         ndr->flags = _flags_save_string;
10843                 }
10844         }
10845         return NDR_ERR_SUCCESS;
10846 }
10847
10848 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
10849 {
10850         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
10851         ndr->depth++;
10852         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10853         ndr->depth++;
10854         if (r->monitor_name) {
10855                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10856         }
10857         ndr->depth--;
10858         ndr->depth--;
10859 }
10860
10861 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
10862 {
10863         if (ndr_flags & NDR_SCALARS) {
10864                 NDR_CHECK(ndr_push_align(ndr, 4));
10865                 {
10866                         uint32_t _flags_save_string = ndr->flags;
10867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10868                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10869                         ndr->flags = _flags_save_string;
10870                 }
10871                 {
10872                         uint32_t _flags_save_string = ndr->flags;
10873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
10875                         ndr->flags = _flags_save_string;
10876                 }
10877                 {
10878                         uint32_t _flags_save_string = ndr->flags;
10879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10880                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
10881                         ndr->flags = _flags_save_string;
10882                 }
10883         }
10884         if (ndr_flags & NDR_BUFFERS) {
10885                 {
10886                         uint32_t _flags_save_string = ndr->flags;
10887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10888                         if (r->monitor_name) {
10889                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10891                         }
10892                         ndr->flags = _flags_save_string;
10893                 }
10894                 {
10895                         uint32_t _flags_save_string = ndr->flags;
10896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10897                         if (r->environment) {
10898                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
10899                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
10900                         }
10901                         ndr->flags = _flags_save_string;
10902                 }
10903                 {
10904                         uint32_t _flags_save_string = ndr->flags;
10905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10906                         if (r->dll_name) {
10907                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
10908                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
10909                         }
10910                         ndr->flags = _flags_save_string;
10911                 }
10912         }
10913         return NDR_ERR_SUCCESS;
10914 }
10915
10916 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
10917 {
10918         uint32_t _ptr_monitor_name;
10919         TALLOC_CTX *_mem_save_monitor_name_0;
10920         uint32_t _ptr_environment;
10921         TALLOC_CTX *_mem_save_environment_0;
10922         uint32_t _ptr_dll_name;
10923         TALLOC_CTX *_mem_save_dll_name_0;
10924         if (ndr_flags & NDR_SCALARS) {
10925                 NDR_CHECK(ndr_pull_align(ndr, 4));
10926                 {
10927                         uint32_t _flags_save_string = ndr->flags;
10928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10929                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10930                         if (_ptr_monitor_name) {
10931                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10932                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10933                         } else {
10934                                 r->monitor_name = NULL;
10935                         }
10936                         ndr->flags = _flags_save_string;
10937                 }
10938                 {
10939                         uint32_t _flags_save_string = ndr->flags;
10940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10941                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
10942                         if (_ptr_environment) {
10943                                 NDR_PULL_ALLOC(ndr, r->environment);
10944                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
10945                         } else {
10946                                 r->environment = NULL;
10947                         }
10948                         ndr->flags = _flags_save_string;
10949                 }
10950                 {
10951                         uint32_t _flags_save_string = ndr->flags;
10952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10953                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
10954                         if (_ptr_dll_name) {
10955                                 NDR_PULL_ALLOC(ndr, r->dll_name);
10956                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
10957                         } else {
10958                                 r->dll_name = NULL;
10959                         }
10960                         ndr->flags = _flags_save_string;
10961                 }
10962         }
10963         if (ndr_flags & NDR_BUFFERS) {
10964                 {
10965                         uint32_t _flags_save_string = ndr->flags;
10966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10967                         if (r->monitor_name) {
10968                                 uint32_t _relative_save_offset;
10969                                 _relative_save_offset = ndr->offset;
10970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10971                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10972                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10975                                 ndr->offset = _relative_save_offset;
10976                         }
10977                         ndr->flags = _flags_save_string;
10978                 }
10979                 {
10980                         uint32_t _flags_save_string = ndr->flags;
10981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10982                         if (r->environment) {
10983                                 uint32_t _relative_save_offset;
10984                                 _relative_save_offset = ndr->offset;
10985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
10986                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
10987                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
10988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
10989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
10990                                 ndr->offset = _relative_save_offset;
10991                         }
10992                         ndr->flags = _flags_save_string;
10993                 }
10994                 {
10995                         uint32_t _flags_save_string = ndr->flags;
10996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10997                         if (r->dll_name) {
10998                                 uint32_t _relative_save_offset;
10999                                 _relative_save_offset = ndr->offset;
11000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
11001                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11002                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
11003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
11004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
11005                                 ndr->offset = _relative_save_offset;
11006                         }
11007                         ndr->flags = _flags_save_string;
11008                 }
11009         }
11010         return NDR_ERR_SUCCESS;
11011 }
11012
11013 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
11014 {
11015         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
11016         ndr->depth++;
11017         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11018         ndr->depth++;
11019         if (r->monitor_name) {
11020                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11021         }
11022         ndr->depth--;
11023         ndr_print_ptr(ndr, "environment", r->environment);
11024         ndr->depth++;
11025         if (r->environment) {
11026                 ndr_print_string(ndr, "environment", r->environment);
11027         }
11028         ndr->depth--;
11029         ndr_print_ptr(ndr, "dll_name", r->dll_name);
11030         ndr->depth++;
11031         if (r->dll_name) {
11032                 ndr_print_string(ndr, "dll_name", r->dll_name);
11033         }
11034         ndr->depth--;
11035         ndr->depth--;
11036 }
11037
11038 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
11039 {
11040         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11041         if (ndr_flags & NDR_SCALARS) {
11042                 int level = ndr_push_get_switch_value(ndr, r);
11043                 switch (level) {
11044                         case 1: {
11045                                 NDR_CHECK(ndr_push_align(ndr, 4));
11046                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11047                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
11048                         break; }
11049
11050                         case 2: {
11051                                 NDR_CHECK(ndr_push_align(ndr, 4));
11052                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11053                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
11054                         break; }
11055
11056                         default: {
11057                         break; }
11058
11059                 }
11060         }
11061         if (ndr_flags & NDR_BUFFERS) {
11062                 int level = ndr_push_get_switch_value(ndr, r);
11063                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11064                 switch (level) {
11065                         case 1:
11066                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
11067                         break;
11068
11069                         case 2:
11070                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
11071                         break;
11072
11073                         default:
11074                         break;
11075
11076                 }
11077         }
11078         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11079         return NDR_ERR_SUCCESS;
11080 }
11081
11082 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
11083 {
11084         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11085         int level;
11086         level = ndr_pull_get_switch_value(ndr, r);
11087         if (ndr_flags & NDR_SCALARS) {
11088                 switch (level) {
11089                         case 1: {
11090                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11091                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11092                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
11093                         break; }
11094
11095                         case 2: {
11096                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11097                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11098                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
11099                         break; }
11100
11101                         default: {
11102                         break; }
11103
11104                 }
11105         }
11106         if (ndr_flags & NDR_BUFFERS) {
11107                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11108                 switch (level) {
11109                         case 1:
11110                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
11111                         break;
11112
11113                         case 2:
11114                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
11115                         break;
11116
11117                         default:
11118                         break;
11119
11120                 }
11121         }
11122         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11123         return NDR_ERR_SUCCESS;
11124 }
11125
11126 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
11127 {
11128         int level;
11129         level = ndr_print_get_switch_value(ndr, r);
11130         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
11131         switch (level) {
11132                 case 1:
11133                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
11134                 break;
11135
11136                 case 2:
11137                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
11138                 break;
11139
11140                 default:
11141                 break;
11142
11143         }
11144 }
11145
11146 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
11147 {
11148         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11149         return NDR_ERR_SUCCESS;
11150 }
11151
11152 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
11153 {
11154         uint32_t v;
11155         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11156         *r = v;
11157         return NDR_ERR_SUCCESS;
11158 }
11159
11160 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
11161 {
11162         ndr_print_uint32(ndr, name, r);
11163         ndr->depth++;
11164         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
11165         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
11166         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
11167         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
11168         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
11169         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
11170         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
11171         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
11172         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
11173         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
11174         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
11175         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
11176         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
11177         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
11178         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
11179         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
11180         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
11181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
11182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
11183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
11184         ndr->depth--;
11185 }
11186
11187 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
11188 {
11189         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
11190         return NDR_ERR_SUCCESS;
11191 }
11192
11193 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
11194 {
11195         uint16_t v;
11196         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
11197         *r = v;
11198         return NDR_ERR_SUCCESS;
11199 }
11200
11201 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
11202 {
11203         const char *val = NULL;
11204
11205         switch (r) {
11206                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
11207                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
11208                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
11209                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
11210                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
11211                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
11212                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
11213                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
11214                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
11215                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
11216                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
11217                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
11218                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
11219                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
11220                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
11221                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
11222                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
11223                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
11224                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
11225                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
11226                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
11227                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
11228                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
11229                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
11230                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
11231                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
11232         }
11233         ndr_print_enum(ndr, name, "ENUM", val, r);
11234 }
11235
11236 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
11237 {
11238         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
11239         return NDR_ERR_SUCCESS;
11240 }
11241
11242 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
11243 {
11244         uint16_t v;
11245         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
11246         *r = v;
11247         return NDR_ERR_SUCCESS;
11248 }
11249
11250 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
11251 {
11252         const char *val = NULL;
11253
11254         switch (r) {
11255                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
11256                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
11257         }
11258         ndr_print_enum(ndr, name, "ENUM", val, r);
11259 }
11260
11261 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
11262 {
11263         uint32_t cntr_fields_1;
11264         if (ndr_flags & NDR_SCALARS) {
11265                 NDR_CHECK(ndr_push_align(ndr, 4));
11266                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
11267                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
11268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
11272         }
11273         if (ndr_flags & NDR_BUFFERS) {
11274                 if (r->fields) {
11275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11276                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
11277                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
11278                         }
11279                 }
11280         }
11281         return NDR_ERR_SUCCESS;
11282 }
11283
11284 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
11285 {
11286         uint32_t _ptr_fields;
11287         uint32_t cntr_fields_1;
11288         TALLOC_CTX *_mem_save_fields_0;
11289         TALLOC_CTX *_mem_save_fields_1;
11290         if (ndr_flags & NDR_SCALARS) {
11291                 NDR_CHECK(ndr_pull_align(ndr, 4));
11292                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
11293                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
11294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
11298                 if (_ptr_fields) {
11299                         NDR_PULL_ALLOC(ndr, r->fields);
11300                 } else {
11301                         r->fields = NULL;
11302                 }
11303         }
11304         if (ndr_flags & NDR_BUFFERS) {
11305                 if (r->fields) {
11306                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
11307                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
11308                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
11309                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
11310                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
11311                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
11312                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
11313                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
11314                         }
11315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
11316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
11317                 }
11318                 if (r->fields) {
11319                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
11320                 }
11321         }
11322         return NDR_ERR_SUCCESS;
11323 }
11324
11325 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
11326 {
11327         uint32_t cntr_fields_1;
11328         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
11329         ndr->depth++;
11330         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
11331         ndr_print_uint16(ndr, "u1", r->u1);
11332         ndr_print_uint32(ndr, "u2", r->u2);
11333         ndr_print_uint32(ndr, "u3", r->u3);
11334         ndr_print_uint32(ndr, "count", r->count);
11335         ndr_print_ptr(ndr, "fields", r->fields);
11336         ndr->depth++;
11337         if (r->fields) {
11338                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
11339                 ndr->depth++;
11340                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
11341                         char *idx_1=NULL;
11342                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
11343                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
11344                                 free(idx_1);
11345                         }
11346                 }
11347                 ndr->depth--;
11348         }
11349         ndr->depth--;
11350         ndr->depth--;
11351 }
11352
11353 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
11354 {
11355         uint32_t cntr_types_1;
11356         if (ndr_flags & NDR_SCALARS) {
11357                 NDR_CHECK(ndr_push_align(ndr, 4));
11358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
11360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
11362         }
11363         if (ndr_flags & NDR_BUFFERS) {
11364                 if (r->types) {
11365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11366                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
11367                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
11368                         }
11369                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
11370                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
11371                         }
11372                 }
11373         }
11374         return NDR_ERR_SUCCESS;
11375 }
11376
11377 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
11378 {
11379         uint32_t _ptr_types;
11380         uint32_t cntr_types_1;
11381         TALLOC_CTX *_mem_save_types_0;
11382         TALLOC_CTX *_mem_save_types_1;
11383         if (ndr_flags & NDR_SCALARS) {
11384                 NDR_CHECK(ndr_pull_align(ndr, 4));
11385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
11387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
11389                 if (_ptr_types) {
11390                         NDR_PULL_ALLOC(ndr, r->types);
11391                 } else {
11392                         r->types = NULL;
11393                 }
11394         }
11395         if (ndr_flags & NDR_BUFFERS) {
11396                 if (r->types) {
11397                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
11398                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
11399                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
11400                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
11401                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
11402                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
11403                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
11404                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
11405                         }
11406                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
11407                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
11408                         }
11409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
11410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
11411                 }
11412                 if (r->types) {
11413                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
11414                 }
11415         }
11416         return NDR_ERR_SUCCESS;
11417 }
11418
11419 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
11420 {
11421         uint32_t cntr_types_1;
11422         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
11423         ndr->depth++;
11424         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
11425         ndr_print_uint32(ndr, "flags", r->flags);
11426         ndr_print_uint32(ndr, "count", r->count);
11427         ndr_print_ptr(ndr, "types", r->types);
11428         ndr->depth++;
11429         if (r->types) {
11430                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
11431                 ndr->depth++;
11432                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
11433                         char *idx_1=NULL;
11434                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
11435                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
11436                                 free(idx_1);
11437                         }
11438                 }
11439                 ndr->depth--;
11440         }
11441         ndr->depth--;
11442         ndr->depth--;
11443 }
11444
11445 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
11446 {
11447         if (ndr_flags & NDR_SCALARS) {
11448                 NDR_CHECK(ndr_push_align(ndr, 4));
11449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
11450                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
11451         }
11452         if (ndr_flags & NDR_BUFFERS) {
11453                 if (r->string) {
11454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
11455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
11456                 }
11457         }
11458         return NDR_ERR_SUCCESS;
11459 }
11460
11461 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
11462 {
11463         uint32_t _ptr_string;
11464         TALLOC_CTX *_mem_save_string_0;
11465         if (ndr_flags & NDR_SCALARS) {
11466                 NDR_CHECK(ndr_pull_align(ndr, 4));
11467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
11468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
11469                 if (_ptr_string) {
11470                         NDR_PULL_ALLOC(ndr, r->string);
11471                 } else {
11472                         r->string = NULL;
11473                 }
11474         }
11475         if (ndr_flags & NDR_BUFFERS) {
11476                 if (r->string) {
11477                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
11478                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
11479                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
11480                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
11481                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
11482                 }
11483                 if (r->string) {
11484                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
11485                 }
11486         }
11487         return NDR_ERR_SUCCESS;
11488 }
11489
11490 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
11491 {
11492         ndr_print_struct(ndr, name, "spoolss_NotifyString");
11493         ndr->depth++;
11494         ndr_print_uint32(ndr, "size", r->size);
11495         ndr_print_ptr(ndr, "string", r->string);
11496         ndr->depth++;
11497         if (r->string) {
11498                 ndr_print_string(ndr, "string", r->string);
11499         }
11500         ndr->depth--;
11501         ndr->depth--;
11502 }
11503
11504 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
11505 {
11506         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11507         return NDR_ERR_SUCCESS;
11508 }
11509
11510 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
11511 {
11512         uint32_t v;
11513         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11514         *r = v;
11515         return NDR_ERR_SUCCESS;
11516 }
11517
11518 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
11519 {
11520         const char *val = NULL;
11521
11522         switch (r) {
11523                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
11524                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
11525                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
11526                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
11527                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
11528         }
11529         ndr_print_enum(ndr, name, "ENUM", val, r);
11530 }
11531
11532 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
11533 {
11534         if (ndr_flags & NDR_SCALARS) {
11535                 int level = ndr_push_get_switch_value(ndr, r);
11536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11537                 switch (level) {
11538                         case 1: {
11539                                 uint32_t cntr_integer_0;
11540                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
11541                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
11542                                 }
11543                         break; }
11544
11545                         case 2: {
11546                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
11547                         break; }
11548
11549                         case 3: {
11550                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
11551                         break; }
11552
11553                         case 4: {
11554                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
11555                         break; }
11556
11557                         case 5: {
11558                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
11559                         break; }
11560
11561                         default:
11562                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11563                 }
11564         }
11565         if (ndr_flags & NDR_BUFFERS) {
11566                 int level = ndr_push_get_switch_value(ndr, r);
11567                 switch (level) {
11568                         case 1:
11569                         break;
11570
11571                         case 2:
11572                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
11573                         break;
11574
11575                         case 3:
11576                                 if (r->devmode) {
11577                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
11578                                 }
11579                         break;
11580
11581                         case 4:
11582                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
11583                         break;
11584
11585                         case 5:
11586                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
11587                         break;
11588
11589                         default:
11590                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11591                 }
11592         }
11593         return NDR_ERR_SUCCESS;
11594 }
11595
11596 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
11597 {
11598         int level;
11599         uint32_t _level;
11600         TALLOC_CTX *_mem_save_devmode_0;
11601         level = ndr_pull_get_switch_value(ndr, r);
11602         if (ndr_flags & NDR_SCALARS) {
11603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11604                 if (_level != level) {
11605                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11606                 }
11607                 switch (level) {
11608                         case 1: {
11609                                 uint32_t cntr_integer_0;
11610                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
11611                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
11612                                 }
11613                         break; }
11614
11615                         case 2: {
11616                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
11617                         break; }
11618
11619                         case 3: {
11620                                 uint32_t _ptr_devmode;
11621                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
11622                                 if (_ptr_devmode) {
11623                                         NDR_PULL_ALLOC(ndr, r->devmode);
11624                                 } else {
11625                                         r->devmode = NULL;
11626                                 }
11627                         break; }
11628
11629                         case 4: {
11630                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
11631                         break; }
11632
11633                         case 5: {
11634                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
11635                         break; }
11636
11637                         default:
11638                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11639                 }
11640         }
11641         if (ndr_flags & NDR_BUFFERS) {
11642                 switch (level) {
11643                         case 1:
11644                         break;
11645
11646                         case 2:
11647                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
11648                         break;
11649
11650                         case 3:
11651                                 if (r->devmode) {
11652                                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
11653                                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
11654                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
11655                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
11656                                 }
11657                         break;
11658
11659                         case 4:
11660                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
11661                         break;
11662
11663                         case 5:
11664                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
11665                         break;
11666
11667                         default:
11668                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11669                 }
11670         }
11671         return NDR_ERR_SUCCESS;
11672 }
11673
11674 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
11675 {
11676         int level;
11677         uint32_t cntr_integer_0;
11678         level = ndr_print_get_switch_value(ndr, r);
11679         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
11680         switch (level) {
11681                 case 1:
11682                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
11683                         ndr->depth++;
11684                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
11685                                 char *idx_0=NULL;
11686                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
11687                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
11688                                         free(idx_0);
11689                                 }
11690                         }
11691                         ndr->depth--;
11692                 break;
11693
11694                 case 2:
11695                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
11696                 break;
11697
11698                 case 3:
11699                         ndr_print_ptr(ndr, "devmode", r->devmode);
11700                         ndr->depth++;
11701                         if (r->devmode) {
11702                                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
11703                         }
11704                         ndr->depth--;
11705                 break;
11706
11707                 case 4:
11708                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
11709                 break;
11710
11711                 case 5:
11712                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
11713                 break;
11714
11715                 default:
11716                         ndr_print_bad_level(ndr, name, level);
11717         }
11718 }
11719
11720 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
11721 {
11722         if (ndr_flags & NDR_SCALARS) {
11723                 NDR_CHECK(ndr_push_align(ndr, 4));
11724                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
11725                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
11726                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
11727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
11728                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
11729                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
11730         }
11731         if (ndr_flags & NDR_BUFFERS) {
11732                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
11733         }
11734         return NDR_ERR_SUCCESS;
11735 }
11736
11737 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
11738 {
11739         if (ndr_flags & NDR_SCALARS) {
11740                 NDR_CHECK(ndr_pull_align(ndr, 4));
11741                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
11742                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
11743                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
11744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
11745                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
11746                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
11747         }
11748         if (ndr_flags & NDR_BUFFERS) {
11749                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
11750         }
11751         return NDR_ERR_SUCCESS;
11752 }
11753
11754 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
11755 {
11756         ndr_print_struct(ndr, name, "spoolss_Notify");
11757         ndr->depth++;
11758         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
11759         ndr_print_spoolss_Field(ndr, "field", r->field);
11760         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
11761         ndr_print_uint32(ndr, "job_id", r->job_id);
11762         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
11763         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
11764         ndr->depth--;
11765 }
11766
11767 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
11768 {
11769         uint32_t cntr_notifies_0;
11770         if (ndr_flags & NDR_SCALARS) {
11771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11772                 NDR_CHECK(ndr_push_align(ndr, 4));
11773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
11775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11776                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
11777                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
11778                 }
11779         }
11780         if (ndr_flags & NDR_BUFFERS) {
11781                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
11782                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
11783                 }
11784         }
11785         return NDR_ERR_SUCCESS;
11786 }
11787
11788 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
11789 {
11790         uint32_t cntr_notifies_0;
11791         TALLOC_CTX *_mem_save_notifies_0;
11792         if (ndr_flags & NDR_SCALARS) {
11793                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
11794                 NDR_CHECK(ndr_pull_align(ndr, 4));
11795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
11797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11798                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
11799                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
11800                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
11801                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
11802                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
11803                 }
11804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
11805                 if (r->notifies) {
11806                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
11807                 }
11808         }
11809         if (ndr_flags & NDR_BUFFERS) {
11810                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
11811                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
11812                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
11813                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
11814                 }
11815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
11816         }
11817         return NDR_ERR_SUCCESS;
11818 }
11819
11820 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
11821 {
11822         uint32_t cntr_notifies_0;
11823         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
11824         ndr->depth++;
11825         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
11826         ndr_print_uint32(ndr, "flags", r->flags);
11827         ndr_print_uint32(ndr, "count", r->count);
11828         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
11829         ndr->depth++;
11830         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
11831                 char *idx_0=NULL;
11832                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
11833                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
11834                         free(idx_0);
11835                 }
11836         }
11837         ndr->depth--;
11838         ndr->depth--;
11839 }
11840
11841 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
11842 {
11843         if (ndr_flags & NDR_SCALARS) {
11844                 int level = ndr_push_get_switch_value(ndr, r);
11845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11846                 switch (level) {
11847                         case 0: {
11848                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
11849                         break; }
11850
11851                         default:
11852                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11853                 }
11854         }
11855         if (ndr_flags & NDR_BUFFERS) {
11856                 int level = ndr_push_get_switch_value(ndr, r);
11857                 switch (level) {
11858                         case 0:
11859                                 if (r->info0) {
11860                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
11861                                 }
11862                         break;
11863
11864                         default:
11865                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11866                 }
11867         }
11868         return NDR_ERR_SUCCESS;
11869 }
11870
11871 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
11872 {
11873         int level;
11874         uint32_t _level;
11875         TALLOC_CTX *_mem_save_info0_0;
11876         level = ndr_pull_get_switch_value(ndr, r);
11877         if (ndr_flags & NDR_SCALARS) {
11878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11879                 if (_level != level) {
11880                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11881                 }
11882                 switch (level) {
11883                         case 0: {
11884                                 uint32_t _ptr_info0;
11885                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
11886                                 if (_ptr_info0) {
11887                                         NDR_PULL_ALLOC(ndr, r->info0);
11888                                 } else {
11889                                         r->info0 = NULL;
11890                                 }
11891                         break; }
11892
11893                         default:
11894                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11895                 }
11896         }
11897         if (ndr_flags & NDR_BUFFERS) {
11898                 switch (level) {
11899                         case 0:
11900                                 if (r->info0) {
11901                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
11902                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
11903                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
11904                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
11905                                 }
11906                         break;
11907
11908                         default:
11909                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11910                 }
11911         }
11912         return NDR_ERR_SUCCESS;
11913 }
11914
11915 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
11916 {
11917         int level;
11918         level = ndr_print_get_switch_value(ndr, r);
11919         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
11920         switch (level) {
11921                 case 0:
11922                         ndr_print_ptr(ndr, "info0", r->info0);
11923                         ndr->depth++;
11924                         if (r->info0) {
11925                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
11926                         }
11927                         ndr->depth--;
11928                 break;
11929
11930                 default:
11931                         ndr_print_bad_level(ndr, name, level);
11932         }
11933 }
11934
11935 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
11936 {
11937         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11938         return NDR_ERR_SUCCESS;
11939 }
11940
11941 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
11942 {
11943         uint32_t v;
11944         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11945         *r = v;
11946         return NDR_ERR_SUCCESS;
11947 }
11948
11949 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
11950 {
11951         ndr_print_uint32(ndr, name, r);
11952         ndr->depth++;
11953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
11954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
11955         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
11956         ndr->depth--;
11957 }
11958
11959 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
11960 {
11961         if (ndr_flags & NDR_SCALARS) {
11962                 NDR_CHECK(ndr_push_align(ndr, 4));
11963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
11964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
11965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
11966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11967                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
11968                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
11969                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
11970         }
11971         if (ndr_flags & NDR_BUFFERS) {
11972                 if (r->client) {
11973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
11974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
11976                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11977                 }
11978                 if (r->user) {
11979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
11980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
11982                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11983                 }
11984         }
11985         return NDR_ERR_SUCCESS;
11986 }
11987
11988 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
11989 {
11990         uint32_t _ptr_client;
11991         TALLOC_CTX *_mem_save_client_0;
11992         uint32_t _ptr_user;
11993         TALLOC_CTX *_mem_save_user_0;
11994         if (ndr_flags & NDR_SCALARS) {
11995                 NDR_CHECK(ndr_pull_align(ndr, 4));
11996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
11997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
11998                 if (_ptr_client) {
11999                         NDR_PULL_ALLOC(ndr, r->client);
12000                 } else {
12001                         r->client = NULL;
12002                 }
12003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
12004                 if (_ptr_user) {
12005                         NDR_PULL_ALLOC(ndr, r->user);
12006                 } else {
12007                         r->user = NULL;
12008                 }
12009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
12010                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
12011                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
12012                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
12013         }
12014         if (ndr_flags & NDR_BUFFERS) {
12015                 if (r->client) {
12016                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
12017                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
12018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
12019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
12020                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
12021                                 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));
12022                         }
12023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
12024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
12025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
12026                 }
12027                 if (r->user) {
12028                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
12029                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
12030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
12031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
12032                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
12033                                 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));
12034                         }
12035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
12036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
12037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
12038                 }
12039         }
12040         return NDR_ERR_SUCCESS;
12041 }
12042
12043 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
12044 {
12045         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
12046         ndr->depth++;
12047         ndr_print_uint32(ndr, "size", r->size);
12048         ndr_print_ptr(ndr, "client", r->client);
12049         ndr->depth++;
12050         if (r->client) {
12051                 ndr_print_string(ndr, "client", r->client);
12052         }
12053         ndr->depth--;
12054         ndr_print_ptr(ndr, "user", r->user);
12055         ndr->depth++;
12056         if (r->user) {
12057                 ndr_print_string(ndr, "user", r->user);
12058         }
12059         ndr->depth--;
12060         ndr_print_uint32(ndr, "build", r->build);
12061         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
12062         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
12063         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
12064         ndr->depth--;
12065 }
12066
12067 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
12068 {
12069         if (ndr_flags & NDR_SCALARS) {
12070                 NDR_CHECK(ndr_push_align(ndr, 4));
12071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
12072         }
12073         if (ndr_flags & NDR_BUFFERS) {
12074         }
12075         return NDR_ERR_SUCCESS;
12076 }
12077
12078 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
12079 {
12080         if (ndr_flags & NDR_SCALARS) {
12081                 NDR_CHECK(ndr_pull_align(ndr, 4));
12082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
12083         }
12084         if (ndr_flags & NDR_BUFFERS) {
12085         }
12086         return NDR_ERR_SUCCESS;
12087 }
12088
12089 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
12090 {
12091         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
12092         ndr->depth++;
12093         ndr_print_uint32(ndr, "not_used", r->not_used);
12094         ndr->depth--;
12095 }
12096
12097 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
12098 {
12099         if (ndr_flags & NDR_SCALARS) {
12100                 NDR_CHECK(ndr_push_align(ndr, 4));
12101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
12102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
12103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
12104                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
12105                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
12106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
12107                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
12108                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
12109                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
12110                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
12111         }
12112         if (ndr_flags & NDR_BUFFERS) {
12113                 if (r->client) {
12114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
12115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
12117                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12118                 }
12119                 if (r->user) {
12120                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
12121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
12123                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12124                 }
12125         }
12126         return NDR_ERR_SUCCESS;
12127 }
12128
12129 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
12130 {
12131         uint32_t _ptr_client;
12132         TALLOC_CTX *_mem_save_client_0;
12133         uint32_t _ptr_user;
12134         TALLOC_CTX *_mem_save_user_0;
12135         if (ndr_flags & NDR_SCALARS) {
12136                 NDR_CHECK(ndr_pull_align(ndr, 4));
12137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
12138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
12139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
12140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
12141                 if (_ptr_client) {
12142                         NDR_PULL_ALLOC(ndr, r->client);
12143                 } else {
12144                         r->client = NULL;
12145                 }
12146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
12147                 if (_ptr_user) {
12148                         NDR_PULL_ALLOC(ndr, r->user);
12149                 } else {
12150                         r->user = NULL;
12151                 }
12152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
12153                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
12154                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
12155                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
12156                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
12157         }
12158         if (ndr_flags & NDR_BUFFERS) {
12159                 if (r->client) {
12160                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
12161                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
12162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
12163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
12164                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
12165                                 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));
12166                         }
12167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
12168                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
12169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
12170                 }
12171                 if (r->user) {
12172                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
12173                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
12174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
12175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
12176                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
12177                                 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));
12178                         }
12179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
12180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
12181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
12182                 }
12183         }
12184         return NDR_ERR_SUCCESS;
12185 }
12186
12187 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
12188 {
12189         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
12190         ndr->depth++;
12191         ndr_print_uint32(ndr, "size", r->size);
12192         ndr_print_uint32(ndr, "flags", r->flags);
12193         ndr_print_uint32(ndr, "size2", r->size2);
12194         ndr_print_ptr(ndr, "client", r->client);
12195         ndr->depth++;
12196         if (r->client) {
12197                 ndr_print_string(ndr, "client", r->client);
12198         }
12199         ndr->depth--;
12200         ndr_print_ptr(ndr, "user", r->user);
12201         ndr->depth++;
12202         if (r->user) {
12203                 ndr_print_string(ndr, "user", r->user);
12204         }
12205         ndr->depth--;
12206         ndr_print_uint32(ndr, "build", r->build);
12207         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
12208         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
12209         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
12210         ndr_print_udlong(ndr, "reserved", r->reserved);
12211         ndr->depth--;
12212 }
12213
12214 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
12215 {
12216         if (ndr_flags & NDR_SCALARS) {
12217                 int level = ndr_push_get_switch_value(ndr, r);
12218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12219                 switch (level) {
12220                         case 1: {
12221                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
12222                         break; }
12223
12224                         case 2: {
12225                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
12226                         break; }
12227
12228                         case 3: {
12229                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
12230                         break; }
12231
12232                         default:
12233                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12234                 }
12235         }
12236         if (ndr_flags & NDR_BUFFERS) {
12237                 int level = ndr_push_get_switch_value(ndr, r);
12238                 switch (level) {
12239                         case 1:
12240                                 if (r->level1) {
12241                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
12242                                 }
12243                         break;
12244
12245                         case 2:
12246                                 if (r->level2) {
12247                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
12248                                 }
12249                         break;
12250
12251                         case 3:
12252                                 if (r->level3) {
12253                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
12254                                 }
12255                         break;
12256
12257                         default:
12258                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12259                 }
12260         }
12261         return NDR_ERR_SUCCESS;
12262 }
12263
12264 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
12265 {
12266         int level;
12267         uint32_t _level;
12268         TALLOC_CTX *_mem_save_level1_0;
12269         TALLOC_CTX *_mem_save_level2_0;
12270         TALLOC_CTX *_mem_save_level3_0;
12271         level = ndr_pull_get_switch_value(ndr, r);
12272         if (ndr_flags & NDR_SCALARS) {
12273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12274                 if (_level != level) {
12275                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12276                 }
12277                 switch (level) {
12278                         case 1: {
12279                                 uint32_t _ptr_level1;
12280                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
12281                                 if (_ptr_level1) {
12282                                         NDR_PULL_ALLOC(ndr, r->level1);
12283                                 } else {
12284                                         r->level1 = NULL;
12285                                 }
12286                         break; }
12287
12288                         case 2: {
12289                                 uint32_t _ptr_level2;
12290                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
12291                                 if (_ptr_level2) {
12292                                         NDR_PULL_ALLOC(ndr, r->level2);
12293                                 } else {
12294                                         r->level2 = NULL;
12295                                 }
12296                         break; }
12297
12298                         case 3: {
12299                                 uint32_t _ptr_level3;
12300                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
12301                                 if (_ptr_level3) {
12302                                         NDR_PULL_ALLOC(ndr, r->level3);
12303                                 } else {
12304                                         r->level3 = NULL;
12305                                 }
12306                         break; }
12307
12308                         default:
12309                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12310                 }
12311         }
12312         if (ndr_flags & NDR_BUFFERS) {
12313                 switch (level) {
12314                         case 1:
12315                                 if (r->level1) {
12316                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12317                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
12318                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
12319                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
12320                                 }
12321                         break;
12322
12323                         case 2:
12324                                 if (r->level2) {
12325                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12326                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
12327                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
12328                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
12329                                 }
12330                         break;
12331
12332                         case 3:
12333                                 if (r->level3) {
12334                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12335                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
12336                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
12337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
12338                                 }
12339                         break;
12340
12341                         default:
12342                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12343                 }
12344         }
12345         return NDR_ERR_SUCCESS;
12346 }
12347
12348 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
12349 {
12350         int level;
12351         level = ndr_print_get_switch_value(ndr, r);
12352         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
12353         switch (level) {
12354                 case 1:
12355                         ndr_print_ptr(ndr, "level1", r->level1);
12356                         ndr->depth++;
12357                         if (r->level1) {
12358                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
12359                         }
12360                         ndr->depth--;
12361                 break;
12362
12363                 case 2:
12364                         ndr_print_ptr(ndr, "level2", r->level2);
12365                         ndr->depth++;
12366                         if (r->level2) {
12367                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
12368                         }
12369                         ndr->depth--;
12370                 break;
12371
12372                 case 3:
12373                         ndr_print_ptr(ndr, "level3", r->level3);
12374                         ndr->depth++;
12375                         if (r->level3) {
12376                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
12377                         }
12378                         ndr->depth--;
12379                 break;
12380
12381                 default:
12382                         ndr_print_bad_level(ndr, name, level);
12383         }
12384 }
12385
12386 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
12387 {
12388         if (ndr_flags & NDR_SCALARS) {
12389                 NDR_CHECK(ndr_push_align(ndr, 4));
12390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
12391                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
12392                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
12393         }
12394         if (ndr_flags & NDR_BUFFERS) {
12395                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
12396         }
12397         return NDR_ERR_SUCCESS;
12398 }
12399
12400 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
12401 {
12402         if (ndr_flags & NDR_SCALARS) {
12403                 NDR_CHECK(ndr_pull_align(ndr, 4));
12404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
12405                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
12406                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
12407         }
12408         if (ndr_flags & NDR_BUFFERS) {
12409                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
12410         }
12411         return NDR_ERR_SUCCESS;
12412 }
12413
12414 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
12415 {
12416         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
12417         ndr->depth++;
12418         ndr_print_uint32(ndr, "level", r->level);
12419         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
12420         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
12421         ndr->depth--;
12422 }
12423
12424 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12425 {
12426         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12427         return NDR_ERR_SUCCESS;
12428 }
12429
12430 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12431 {
12432         uint32_t v;
12433         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12434         *r = v;
12435         return NDR_ERR_SUCCESS;
12436 }
12437
12438 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
12439 {
12440         ndr_print_uint32(ndr, name, r);
12441         ndr->depth++;
12442         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
12443         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
12444         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
12445         ndr->depth--;
12446 }
12447
12448 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12449 {
12450         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12451         return NDR_ERR_SUCCESS;
12452 }
12453
12454 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12455 {
12456         uint32_t v;
12457         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12458         *r = v;
12459         return NDR_ERR_SUCCESS;
12460 }
12461
12462 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
12463 {
12464         ndr_print_uint32(ndr, name, r);
12465         ndr->depth++;
12466         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
12467         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
12468         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
12469         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
12470         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
12471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
12472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
12473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
12474         ndr->depth--;
12475 }
12476
12477 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
12478 {
12479         if (flags & NDR_IN) {
12480                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
12481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
12482                 if (r->in.server) {
12483                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
12484                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12485                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
12486                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12487                 }
12488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12490                 if (r->in.buffer) {
12491                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12492                 }
12493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12494         }
12495         if (flags & NDR_OUT) {
12496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12497                 if (r->out.info) {
12498                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12499                 }
12500                 if (r->out.needed == NULL) {
12501                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12502                 }
12503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12505                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12506         }
12507         return NDR_ERR_SUCCESS;
12508 }
12509
12510 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
12511 {
12512         uint32_t _ptr_server;
12513         uint32_t _ptr_buffer;
12514         uint32_t _ptr_info;
12515         TALLOC_CTX *_mem_save_server_0;
12516         TALLOC_CTX *_mem_save_buffer_0;
12517         TALLOC_CTX *_mem_save_info_0;
12518         TALLOC_CTX *_mem_save_needed_0;
12519         if (flags & NDR_IN) {
12520                 ZERO_STRUCT(r->out);
12521
12522                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
12523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
12524                 if (_ptr_server) {
12525                         NDR_PULL_ALLOC(ndr, r->in.server);
12526                 } else {
12527                         r->in.server = NULL;
12528                 }
12529                 if (r->in.server) {
12530                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
12531                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
12532                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
12533                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
12534                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
12535                                 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));
12536                         }
12537                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
12538                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
12539                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
12540                 }
12541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12543                 if (_ptr_buffer) {
12544                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12545                 } else {
12546                         r->in.buffer = NULL;
12547                 }
12548                 if (r->in.buffer) {
12549                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12550                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12551                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12553                 }
12554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12555                 NDR_PULL_ALLOC(ndr, r->out.needed);
12556                 ZERO_STRUCTP(r->out.needed);
12557         }
12558         if (flags & NDR_OUT) {
12559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12560                 if (_ptr_info) {
12561                         NDR_PULL_ALLOC(ndr, r->out.info);
12562                 } else {
12563                         r->out.info = NULL;
12564                 }
12565                 if (r->out.info) {
12566                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12567                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12568                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12570                 }
12571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12572                         NDR_PULL_ALLOC(ndr, r->out.needed);
12573                 }
12574                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12580         }
12581         return NDR_ERR_SUCCESS;
12582 }
12583
12584 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
12585 {
12586         uint32_t cntr_info_0;
12587         if (flags & NDR_IN) {
12588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12590         }
12591         if (flags & NDR_OUT) {
12592                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12593                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12594                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12595                 }
12596                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12597                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12598                 }
12599         }
12600         return NDR_ERR_SUCCESS;
12601 }
12602
12603 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
12604 {
12605         uint32_t cntr_info_0;
12606         TALLOC_CTX *_mem_save_info_0;
12607         if (flags & NDR_IN) {
12608                 ZERO_STRUCT(r->out);
12609
12610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12612         }
12613         if (flags & NDR_OUT) {
12614                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12615                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12616                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12617                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12618                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12619                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12620                 }
12621                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12622                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12623                 }
12624                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12625         }
12626         return NDR_ERR_SUCCESS;
12627 }
12628
12629 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
12630 {
12631         uint32_t cntr_info_1;
12632         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
12633         ndr->depth++;
12634         if (flags & NDR_SET_VALUES) {
12635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12636         }
12637         if (flags & NDR_IN) {
12638                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
12639                 ndr->depth++;
12640                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
12641                 ndr_print_ptr(ndr, "server", r->in.server);
12642                 ndr->depth++;
12643                 if (r->in.server) {
12644                         ndr_print_string(ndr, "server", r->in.server);
12645                 }
12646                 ndr->depth--;
12647                 ndr_print_uint32(ndr, "level", r->in.level);
12648                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12649                 ndr->depth++;
12650                 if (r->in.buffer) {
12651                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12652                 }
12653                 ndr->depth--;
12654                 ndr_print_uint32(ndr, "offered", r->in.offered);
12655                 ndr->depth--;
12656         }
12657         if (flags & NDR_OUT) {
12658                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
12659                 ndr->depth++;
12660                 ndr_print_ptr(ndr, "info", r->out.info);
12661                 ndr->depth++;
12662                 if (r->out.info) {
12663                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12664                         ndr->depth++;
12665                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12666                                 char *idx_1=NULL;
12667                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12668                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12669                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
12670                                         free(idx_1);
12671                                 }
12672                         }
12673                         ndr->depth--;
12674                 }
12675                 ndr->depth--;
12676                 ndr_print_ptr(ndr, "needed", r->out.needed);
12677                 ndr->depth++;
12678                 ndr_print_uint32(ndr, "needed", *r->out.needed);
12679                 ndr->depth--;
12680                 ndr_print_uint32(ndr, "count", r->out.count);
12681                 ndr_print_WERROR(ndr, "result", r->out.result);
12682                 ndr->depth--;
12683         }
12684         ndr->depth--;
12685 }
12686
12687 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
12688 {
12689         if (flags & NDR_IN) {
12690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
12691                 if (r->in.printername) {
12692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
12693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12694                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
12695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12696                 }
12697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
12698                 if (r->in.datatype) {
12699                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
12700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
12702                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12703                 }
12704                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
12705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
12706         }
12707         if (flags & NDR_OUT) {
12708                 if (r->out.handle == NULL) {
12709                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12710                 }
12711                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
12712                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12713         }
12714         return NDR_ERR_SUCCESS;
12715 }
12716
12717 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
12718 {
12719         uint32_t _ptr_printername;
12720         uint32_t _ptr_datatype;
12721         TALLOC_CTX *_mem_save_printername_0;
12722         TALLOC_CTX *_mem_save_datatype_0;
12723         TALLOC_CTX *_mem_save_handle_0;
12724         if (flags & NDR_IN) {
12725                 ZERO_STRUCT(r->out);
12726
12727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
12728                 if (_ptr_printername) {
12729                         NDR_PULL_ALLOC(ndr, r->in.printername);
12730                 } else {
12731                         r->in.printername = NULL;
12732                 }
12733                 if (r->in.printername) {
12734                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
12735                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
12736                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
12737                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
12738                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
12739                                 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));
12740                         }
12741                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
12742                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
12743                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
12744                 }
12745                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
12746                 if (_ptr_datatype) {
12747                         NDR_PULL_ALLOC(ndr, r->in.datatype);
12748                 } else {
12749                         r->in.datatype = NULL;
12750                 }
12751                 if (r->in.datatype) {
12752                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12753                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
12754                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
12755                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
12756                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
12757                                 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));
12758                         }
12759                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
12760                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
12761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
12762                 }
12763                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
12764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
12765                 NDR_PULL_ALLOC(ndr, r->out.handle);
12766                 ZERO_STRUCTP(r->out.handle);
12767         }
12768         if (flags & NDR_OUT) {
12769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12770                         NDR_PULL_ALLOC(ndr, r->out.handle);
12771                 }
12772                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12773                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
12774                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
12775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12776                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12777         }
12778         return NDR_ERR_SUCCESS;
12779 }
12780
12781 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
12782 {
12783         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
12784         ndr->depth++;
12785         if (flags & NDR_SET_VALUES) {
12786                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12787         }
12788         if (flags & NDR_IN) {
12789                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
12790                 ndr->depth++;
12791                 ndr_print_ptr(ndr, "printername", r->in.printername);
12792                 ndr->depth++;
12793                 if (r->in.printername) {
12794                         ndr_print_string(ndr, "printername", r->in.printername);
12795                 }
12796                 ndr->depth--;
12797                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
12798                 ndr->depth++;
12799                 if (r->in.datatype) {
12800                         ndr_print_string(ndr, "datatype", r->in.datatype);
12801                 }
12802                 ndr->depth--;
12803                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
12804                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
12805                 ndr->depth--;
12806         }
12807         if (flags & NDR_OUT) {
12808                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
12809                 ndr->depth++;
12810                 ndr_print_ptr(ndr, "handle", r->out.handle);
12811                 ndr->depth++;
12812                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
12813                 ndr->depth--;
12814                 ndr_print_WERROR(ndr, "result", r->out.result);
12815                 ndr->depth--;
12816         }
12817         ndr->depth--;
12818 }
12819
12820 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
12821 {
12822         if (flags & NDR_IN) {
12823                 if (r->in.handle == NULL) {
12824                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12825                 }
12826                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
12828                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
12829                 if (r->in.ctr) {
12830                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
12831                 }
12832                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
12833         }
12834         if (flags & NDR_OUT) {
12835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12836         }
12837         return NDR_ERR_SUCCESS;
12838 }
12839
12840 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
12841 {
12842         uint32_t _ptr_ctr;
12843         TALLOC_CTX *_mem_save_handle_0;
12844         TALLOC_CTX *_mem_save_ctr_0;
12845         if (flags & NDR_IN) {
12846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12847                         NDR_PULL_ALLOC(ndr, r->in.handle);
12848                 }
12849                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12850                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12851                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12852                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
12854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
12855                 if (_ptr_ctr) {
12856                         NDR_PULL_ALLOC(ndr, r->in.ctr);
12857                 } else {
12858                         r->in.ctr = NULL;
12859                 }
12860                 if (r->in.ctr) {
12861                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12862                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
12863                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
12864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
12865                 }
12866                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
12867         }
12868         if (flags & NDR_OUT) {
12869                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12870         }
12871         return NDR_ERR_SUCCESS;
12872 }
12873
12874 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
12875 {
12876         ndr_print_struct(ndr, name, "spoolss_SetJob");
12877         ndr->depth++;
12878         if (flags & NDR_SET_VALUES) {
12879                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12880         }
12881         if (flags & NDR_IN) {
12882                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
12883                 ndr->depth++;
12884                 ndr_print_ptr(ndr, "handle", r->in.handle);
12885                 ndr->depth++;
12886                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12887                 ndr->depth--;
12888                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
12889                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
12890                 ndr->depth++;
12891                 if (r->in.ctr) {
12892                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
12893                 }
12894                 ndr->depth--;
12895                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
12896                 ndr->depth--;
12897         }
12898         if (flags & NDR_OUT) {
12899                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
12900                 ndr->depth++;
12901                 ndr_print_WERROR(ndr, "result", r->out.result);
12902                 ndr->depth--;
12903         }
12904         ndr->depth--;
12905 }
12906
12907 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
12908 {
12909         if (flags & NDR_IN) {
12910                 if (r->in.handle == NULL) {
12911                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12912                 }
12913                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
12915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12917                 if (r->in.buffer) {
12918                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12919                 }
12920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12921         }
12922         if (flags & NDR_OUT) {
12923                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12924                 if (r->out.info) {
12925                         {
12926                                 struct ndr_push *_ndr_info;
12927                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
12928                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
12929                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
12930                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
12931                         }
12932                 }
12933                 if (r->out.needed == NULL) {
12934                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12935                 }
12936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12937                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12938         }
12939         return NDR_ERR_SUCCESS;
12940 }
12941
12942 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
12943 {
12944         uint32_t _ptr_buffer;
12945         uint32_t _ptr_info;
12946         TALLOC_CTX *_mem_save_handle_0;
12947         TALLOC_CTX *_mem_save_buffer_0;
12948         TALLOC_CTX *_mem_save_info_0;
12949         TALLOC_CTX *_mem_save_needed_0;
12950         if (flags & NDR_IN) {
12951                 ZERO_STRUCT(r->out);
12952
12953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12954                         NDR_PULL_ALLOC(ndr, r->in.handle);
12955                 }
12956                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12957                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12958                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
12961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12963                 if (_ptr_buffer) {
12964                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12965                 } else {
12966                         r->in.buffer = NULL;
12967                 }
12968                 if (r->in.buffer) {
12969                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12970                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12971                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12972                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12973                 }
12974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12975                 NDR_PULL_ALLOC(ndr, r->out.needed);
12976                 ZERO_STRUCTP(r->out.needed);
12977         }
12978         if (flags & NDR_OUT) {
12979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12980                 if (_ptr_info) {
12981                         NDR_PULL_ALLOC(ndr, r->out.info);
12982                 } else {
12983                         r->out.info = NULL;
12984                 }
12985                 if (r->out.info) {
12986                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12987                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12988                         {
12989                                 struct ndr_pull *_ndr_info;
12990                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
12991                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
12992                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
12993                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
12994                         }
12995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12996                 }
12997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12998                         NDR_PULL_ALLOC(ndr, r->out.needed);
12999                 }
13000                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
13001                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
13002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
13003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
13004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13005         }
13006         return NDR_ERR_SUCCESS;
13007 }
13008
13009 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
13010 {
13011         ndr_print_struct(ndr, name, "spoolss_GetJob");
13012         ndr->depth++;
13013         if (flags & NDR_SET_VALUES) {
13014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13015         }
13016         if (flags & NDR_IN) {
13017                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
13018                 ndr->depth++;
13019                 ndr_print_ptr(ndr, "handle", r->in.handle);
13020                 ndr->depth++;
13021                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13022                 ndr->depth--;
13023                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
13024                 ndr_print_uint32(ndr, "level", r->in.level);
13025                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13026                 ndr->depth++;
13027                 if (r->in.buffer) {
13028                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13029                 }
13030                 ndr->depth--;
13031                 ndr_print_uint32(ndr, "offered", r->in.offered);
13032                 ndr->depth--;
13033         }
13034         if (flags & NDR_OUT) {
13035                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
13036                 ndr->depth++;
13037                 ndr_print_ptr(ndr, "info", r->out.info);
13038                 ndr->depth++;
13039                 if (r->out.info) {
13040                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
13041                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
13042                 }
13043                 ndr->depth--;
13044                 ndr_print_ptr(ndr, "needed", r->out.needed);
13045                 ndr->depth++;
13046                 ndr_print_uint32(ndr, "needed", *r->out.needed);
13047                 ndr->depth--;
13048                 ndr_print_WERROR(ndr, "result", r->out.result);
13049                 ndr->depth--;
13050         }
13051         ndr->depth--;
13052 }
13053
13054 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
13055 {
13056         if (flags & NDR_IN) {
13057                 if (r->in.handle == NULL) {
13058                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13059                 }
13060                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
13062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
13063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
13065                 if (r->in.buffer) {
13066                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13067                 }
13068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13069         }
13070         if (flags & NDR_OUT) {
13071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13072                 if (r->out.info) {
13073                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
13074                 }
13075                 if (r->out.needed == NULL) {
13076                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13077                 }
13078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
13079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
13080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13081         }
13082         return NDR_ERR_SUCCESS;
13083 }
13084
13085 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
13086 {
13087         uint32_t _ptr_buffer;
13088         uint32_t _ptr_info;
13089         TALLOC_CTX *_mem_save_handle_0;
13090         TALLOC_CTX *_mem_save_buffer_0;
13091         TALLOC_CTX *_mem_save_info_0;
13092         TALLOC_CTX *_mem_save_needed_0;
13093         if (flags & NDR_IN) {
13094                 ZERO_STRUCT(r->out);
13095
13096                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13097                         NDR_PULL_ALLOC(ndr, r->in.handle);
13098                 }
13099                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13100                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13101                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
13104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
13105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
13107                 if (_ptr_buffer) {
13108                         NDR_PULL_ALLOC(ndr, r->in.buffer);
13109                 } else {
13110                         r->in.buffer = NULL;
13111                 }
13112                 if (r->in.buffer) {
13113                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
13114                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
13115                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
13116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
13117                 }
13118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
13119                 NDR_PULL_ALLOC(ndr, r->out.needed);
13120                 ZERO_STRUCTP(r->out.needed);
13121         }
13122         if (flags & NDR_OUT) {
13123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13124                 if (_ptr_info) {
13125                         NDR_PULL_ALLOC(ndr, r->out.info);
13126                 } else {
13127                         r->out.info = NULL;
13128                 }
13129                 if (r->out.info) {
13130                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13131                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13132                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
13133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13134                 }
13135                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13136                         NDR_PULL_ALLOC(ndr, r->out.needed);
13137                 }
13138                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
13139                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
13140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
13141                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
13142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
13143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13144         }
13145         return NDR_ERR_SUCCESS;
13146 }
13147
13148 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
13149 {
13150         uint32_t cntr_info_0;
13151         if (flags & NDR_IN) {
13152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
13154         }
13155         if (flags & NDR_OUT) {
13156                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13157                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
13158                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
13159                 }
13160                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13161                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
13162                 }
13163         }
13164         return NDR_ERR_SUCCESS;
13165 }
13166
13167 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
13168 {
13169         uint32_t cntr_info_0;
13170         TALLOC_CTX *_mem_save_info_0;
13171         if (flags & NDR_IN) {
13172                 ZERO_STRUCT(r->out);
13173
13174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
13176         }
13177         if (flags & NDR_OUT) {
13178                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
13179                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13180                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13181                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13182                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
13183                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
13184                 }
13185                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13186                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
13187                 }
13188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13189         }
13190         return NDR_ERR_SUCCESS;
13191 }
13192
13193 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
13194 {
13195         uint32_t cntr_info_1;
13196         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
13197         ndr->depth++;
13198         if (flags & NDR_SET_VALUES) {
13199                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13200         }
13201         if (flags & NDR_IN) {
13202                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
13203                 ndr->depth++;
13204                 ndr_print_ptr(ndr, "handle", r->in.handle);
13205                 ndr->depth++;
13206                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13207                 ndr->depth--;
13208                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
13209                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
13210                 ndr_print_uint32(ndr, "level", r->in.level);
13211                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13212                 ndr->depth++;
13213                 if (r->in.buffer) {
13214                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13215                 }
13216                 ndr->depth--;
13217                 ndr_print_uint32(ndr, "offered", r->in.offered);
13218                 ndr->depth--;
13219         }
13220         if (flags & NDR_OUT) {
13221                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
13222                 ndr->depth++;
13223                 ndr_print_ptr(ndr, "info", r->out.info);
13224                 ndr->depth++;
13225                 if (r->out.info) {
13226                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
13227                         ndr->depth++;
13228                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
13229                                 char *idx_1=NULL;
13230                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13231                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
13232                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
13233                                         free(idx_1);
13234                                 }
13235                         }
13236                         ndr->depth--;
13237                 }
13238                 ndr->depth--;
13239                 ndr_print_ptr(ndr, "needed", r->out.needed);
13240                 ndr->depth++;
13241                 ndr_print_uint32(ndr, "needed", *r->out.needed);
13242                 ndr->depth--;
13243                 ndr_print_uint32(ndr, "count", r->out.count);
13244                 ndr_print_WERROR(ndr, "result", r->out.result);
13245                 ndr->depth--;
13246         }
13247         ndr->depth--;
13248 }
13249
13250 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
13251 {
13252         if (flags & NDR_IN) {
13253         }
13254         if (flags & NDR_OUT) {
13255                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13256         }
13257         return NDR_ERR_SUCCESS;
13258 }
13259
13260 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
13261 {
13262         if (flags & NDR_IN) {
13263         }
13264         if (flags & NDR_OUT) {
13265                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13266         }
13267         return NDR_ERR_SUCCESS;
13268 }
13269
13270 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
13271 {
13272         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
13273         ndr->depth++;
13274         if (flags & NDR_SET_VALUES) {
13275                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13276         }
13277         if (flags & NDR_IN) {
13278                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
13279                 ndr->depth++;
13280                 ndr->depth--;
13281         }
13282         if (flags & NDR_OUT) {
13283                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
13284                 ndr->depth++;
13285                 ndr_print_WERROR(ndr, "result", r->out.result);
13286                 ndr->depth--;
13287         }
13288         ndr->depth--;
13289 }
13290
13291 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
13292 {
13293         if (flags & NDR_IN) {
13294                 if (r->in.handle == NULL) {
13295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13296                 }
13297                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13298         }
13299         if (flags & NDR_OUT) {
13300                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13301         }
13302         return NDR_ERR_SUCCESS;
13303 }
13304
13305 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
13306 {
13307         TALLOC_CTX *_mem_save_handle_0;
13308         if (flags & NDR_IN) {
13309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13310                         NDR_PULL_ALLOC(ndr, r->in.handle);
13311                 }
13312                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13313                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13314                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13316         }
13317         if (flags & NDR_OUT) {
13318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13319         }
13320         return NDR_ERR_SUCCESS;
13321 }
13322
13323 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
13324 {
13325         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
13326         ndr->depth++;
13327         if (flags & NDR_SET_VALUES) {
13328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13329         }
13330         if (flags & NDR_IN) {
13331                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
13332                 ndr->depth++;
13333                 ndr_print_ptr(ndr, "handle", r->in.handle);
13334                 ndr->depth++;
13335                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13336                 ndr->depth--;
13337                 ndr->depth--;
13338         }
13339         if (flags & NDR_OUT) {
13340                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
13341                 ndr->depth++;
13342                 ndr_print_WERROR(ndr, "result", r->out.result);
13343                 ndr->depth--;
13344         }
13345         ndr->depth--;
13346 }
13347
13348 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
13349 {
13350         if (flags & NDR_IN) {
13351                 if (r->in.handle == NULL) {
13352                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13353                 }
13354                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13355                 if (r->in.info_ctr == NULL) {
13356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13357                 }
13358                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
13359                 if (r->in.devmode_ctr == NULL) {
13360                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13361                 }
13362                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
13363                 if (r->in.secdesc_ctr == NULL) {
13364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13365                 }
13366                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
13367                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
13368         }
13369         if (flags & NDR_OUT) {
13370                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13371         }
13372         return NDR_ERR_SUCCESS;
13373 }
13374
13375 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
13376 {
13377         TALLOC_CTX *_mem_save_handle_0;
13378         TALLOC_CTX *_mem_save_info_ctr_0;
13379         TALLOC_CTX *_mem_save_devmode_ctr_0;
13380         TALLOC_CTX *_mem_save_secdesc_ctr_0;
13381         if (flags & NDR_IN) {
13382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13383                         NDR_PULL_ALLOC(ndr, r->in.handle);
13384                 }
13385                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13386                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13387                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13390                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
13391                 }
13392                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13393                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
13394                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
13395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13397                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
13398                 }
13399                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13400                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
13401                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
13402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13403                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13404                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
13405                 }
13406                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13407                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
13408                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
13409                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13410                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
13411         }
13412         if (flags & NDR_OUT) {
13413                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13414         }
13415         return NDR_ERR_SUCCESS;
13416 }
13417
13418 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
13419 {
13420         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
13421         ndr->depth++;
13422         if (flags & NDR_SET_VALUES) {
13423                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13424         }
13425         if (flags & NDR_IN) {
13426                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
13427                 ndr->depth++;
13428                 ndr_print_ptr(ndr, "handle", r->in.handle);
13429                 ndr->depth++;
13430                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13431                 ndr->depth--;
13432                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
13433                 ndr->depth++;
13434                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
13435                 ndr->depth--;
13436                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
13437                 ndr->depth++;
13438                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
13439                 ndr->depth--;
13440                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
13441                 ndr->depth++;
13442                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
13443                 ndr->depth--;
13444                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
13445                 ndr->depth--;
13446         }
13447         if (flags & NDR_OUT) {
13448                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
13449                 ndr->depth++;
13450                 ndr_print_WERROR(ndr, "result", r->out.result);
13451                 ndr->depth--;
13452         }
13453         ndr->depth--;
13454 }
13455
13456 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
13457 {
13458         if (flags & NDR_IN) {
13459                 if (r->in.handle == NULL) {
13460                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13461                 }
13462                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
13465                 if (r->in.buffer) {
13466                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13467                 }
13468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13469         }
13470         if (flags & NDR_OUT) {
13471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13472                 if (r->out.info) {
13473                         {
13474                                 struct ndr_push *_ndr_info;
13475                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
13476                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
13477                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13478                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
13479                         }
13480                 }
13481                 if (r->out.needed == NULL) {
13482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13483                 }
13484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
13485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13486         }
13487         return NDR_ERR_SUCCESS;
13488 }
13489
13490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
13491 {
13492         uint32_t _ptr_buffer;
13493         uint32_t _ptr_info;
13494         TALLOC_CTX *_mem_save_handle_0;
13495         TALLOC_CTX *_mem_save_buffer_0;
13496         TALLOC_CTX *_mem_save_info_0;
13497         TALLOC_CTX *_mem_save_needed_0;
13498         if (flags & NDR_IN) {
13499                 ZERO_STRUCT(r->out);
13500
13501                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13502                         NDR_PULL_ALLOC(ndr, r->in.handle);
13503                 }
13504                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13505                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13506                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
13510                 if (_ptr_buffer) {
13511                         NDR_PULL_ALLOC(ndr, r->in.buffer);
13512                 } else {
13513                         r->in.buffer = NULL;
13514                 }
13515                 if (r->in.buffer) {
13516                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
13517                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
13518                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
13519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
13520                 }
13521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
13522                 NDR_PULL_ALLOC(ndr, r->out.needed);
13523                 ZERO_STRUCTP(r->out.needed);
13524         }
13525         if (flags & NDR_OUT) {
13526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13527                 if (_ptr_info) {
13528                         NDR_PULL_ALLOC(ndr, r->out.info);
13529                 } else {
13530                         r->out.info = NULL;
13531                 }
13532                 if (r->out.info) {
13533                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13534                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13535                         {
13536                                 struct ndr_pull *_ndr_info;
13537                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
13538                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
13539                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13540                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
13541                         }
13542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13543                 }
13544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13545                         NDR_PULL_ALLOC(ndr, r->out.needed);
13546                 }
13547                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
13548                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
13549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
13550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
13551                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13552         }
13553         return NDR_ERR_SUCCESS;
13554 }
13555
13556 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
13557 {
13558         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
13559         ndr->depth++;
13560         if (flags & NDR_SET_VALUES) {
13561                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13562         }
13563         if (flags & NDR_IN) {
13564                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
13565                 ndr->depth++;
13566                 ndr_print_ptr(ndr, "handle", r->in.handle);
13567                 ndr->depth++;
13568                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13569                 ndr->depth--;
13570                 ndr_print_uint32(ndr, "level", r->in.level);
13571                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13572                 ndr->depth++;
13573                 if (r->in.buffer) {
13574                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13575                 }
13576                 ndr->depth--;
13577                 ndr_print_uint32(ndr, "offered", r->in.offered);
13578                 ndr->depth--;
13579         }
13580         if (flags & NDR_OUT) {
13581                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
13582                 ndr->depth++;
13583                 ndr_print_ptr(ndr, "info", r->out.info);
13584                 ndr->depth++;
13585                 if (r->out.info) {
13586                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
13587                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
13588                 }
13589                 ndr->depth--;
13590                 ndr_print_ptr(ndr, "needed", r->out.needed);
13591                 ndr->depth++;
13592                 ndr_print_uint32(ndr, "needed", *r->out.needed);
13593                 ndr->depth--;
13594                 ndr_print_WERROR(ndr, "result", r->out.result);
13595                 ndr->depth--;
13596         }
13597         ndr->depth--;
13598 }
13599
13600 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
13601 {
13602         if (flags & NDR_IN) {
13603                 if (r->in.servername == NULL) {
13604                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13605                 }
13606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
13607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
13609                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13611                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
13612                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
13613         }
13614         if (flags & NDR_OUT) {
13615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13616         }
13617         return NDR_ERR_SUCCESS;
13618 }
13619
13620 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
13621 {
13622         if (flags & NDR_IN) {
13623                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
13624                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
13625                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
13626                         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));
13627                 }
13628                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
13629                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
13630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13631                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
13632                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
13633         }
13634         if (flags & NDR_OUT) {
13635                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13636         }
13637         return NDR_ERR_SUCCESS;
13638 }
13639
13640 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
13641 {
13642         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
13643         ndr->depth++;
13644         if (flags & NDR_SET_VALUES) {
13645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13646         }
13647         if (flags & NDR_IN) {
13648                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
13649                 ndr->depth++;
13650                 ndr_print_ptr(ndr, "servername", r->in.servername);
13651                 ndr->depth++;
13652                 ndr_print_string(ndr, "servername", r->in.servername);
13653                 ndr->depth--;
13654                 ndr_print_uint32(ndr, "level", r->in.level);
13655                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
13656                 ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->in.info);
13657                 ndr->depth--;
13658         }
13659         if (flags & NDR_OUT) {
13660                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
13661                 ndr->depth++;
13662                 ndr_print_WERROR(ndr, "result", r->out.result);
13663                 ndr->depth--;
13664         }
13665         ndr->depth--;
13666 }
13667
13668 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
13669 {
13670         if (flags & NDR_IN) {
13671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
13672                 if (r->in.server) {
13673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
13674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
13676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13677                 }
13678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
13679                 if (r->in.environment) {
13680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
13681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
13683                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13684                 }
13685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
13687                 if (r->in.buffer) {
13688                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13689                 }
13690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13691         }
13692         if (flags & NDR_OUT) {
13693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13694                 if (r->out.info) {
13695                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
13696                 }
13697                 if (r->out.needed == NULL) {
13698                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13699                 }
13700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
13701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
13702                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13703         }
13704         return NDR_ERR_SUCCESS;
13705 }
13706
13707 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
13708 {
13709         uint32_t _ptr_server;
13710         uint32_t _ptr_environment;
13711         uint32_t _ptr_buffer;
13712         uint32_t _ptr_info;
13713         TALLOC_CTX *_mem_save_server_0;
13714         TALLOC_CTX *_mem_save_environment_0;
13715         TALLOC_CTX *_mem_save_buffer_0;
13716         TALLOC_CTX *_mem_save_info_0;
13717         TALLOC_CTX *_mem_save_needed_0;
13718         if (flags & NDR_IN) {
13719                 ZERO_STRUCT(r->out);
13720
13721                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
13722                 if (_ptr_server) {
13723                         NDR_PULL_ALLOC(ndr, r->in.server);
13724                 } else {
13725                         r->in.server = NULL;
13726                 }
13727                 if (r->in.server) {
13728                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
13729                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
13730                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
13731                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
13732                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
13733                                 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));
13734                         }
13735                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
13736                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
13737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
13738                 }
13739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
13740                 if (_ptr_environment) {
13741                         NDR_PULL_ALLOC(ndr, r->in.environment);
13742                 } else {
13743                         r->in.environment = NULL;
13744                 }
13745                 if (r->in.environment) {
13746                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
13747                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
13748                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
13749                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
13750                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
13751                                 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));
13752                         }
13753                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
13754                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
13755                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
13756                 }
13757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
13759                 if (_ptr_buffer) {
13760                         NDR_PULL_ALLOC(ndr, r->in.buffer);
13761                 } else {
13762                         r->in.buffer = NULL;
13763                 }
13764                 if (r->in.buffer) {
13765                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
13766                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
13767                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
13768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
13769                 }
13770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
13771                 NDR_PULL_ALLOC(ndr, r->out.needed);
13772                 ZERO_STRUCTP(r->out.needed);
13773         }
13774         if (flags & NDR_OUT) {
13775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13776                 if (_ptr_info) {
13777                         NDR_PULL_ALLOC(ndr, r->out.info);
13778                 } else {
13779                         r->out.info = NULL;
13780                 }
13781                 if (r->out.info) {
13782                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13783                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13784                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
13785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13786                 }
13787                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13788                         NDR_PULL_ALLOC(ndr, r->out.needed);
13789                 }
13790                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
13791                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
13792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
13793                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
13794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
13795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13796         }
13797         return NDR_ERR_SUCCESS;
13798 }
13799
13800 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
13801 {
13802         uint32_t cntr_info_0;
13803         if (flags & NDR_IN) {
13804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
13806         }
13807         if (flags & NDR_OUT) {
13808                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13809                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
13810                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
13811                 }
13812                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13813                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
13814                 }
13815         }
13816         return NDR_ERR_SUCCESS;
13817 }
13818
13819 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
13820 {
13821         uint32_t cntr_info_0;
13822         TALLOC_CTX *_mem_save_info_0;
13823         if (flags & NDR_IN) {
13824                 ZERO_STRUCT(r->out);
13825
13826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
13828         }
13829         if (flags & NDR_OUT) {
13830                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
13831                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13832                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13833                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13834                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
13835                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
13836                 }
13837                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13838                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
13839                 }
13840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13841         }
13842         return NDR_ERR_SUCCESS;
13843 }
13844
13845 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
13846 {
13847         uint32_t cntr_info_1;
13848         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
13849         ndr->depth++;
13850         if (flags & NDR_SET_VALUES) {
13851                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13852         }
13853         if (flags & NDR_IN) {
13854                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
13855                 ndr->depth++;
13856                 ndr_print_ptr(ndr, "server", r->in.server);
13857                 ndr->depth++;
13858                 if (r->in.server) {
13859                         ndr_print_string(ndr, "server", r->in.server);
13860                 }
13861                 ndr->depth--;
13862                 ndr_print_ptr(ndr, "environment", r->in.environment);
13863                 ndr->depth++;
13864                 if (r->in.environment) {
13865                         ndr_print_string(ndr, "environment", r->in.environment);
13866                 }
13867                 ndr->depth--;
13868                 ndr_print_uint32(ndr, "level", r->in.level);
13869                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13870                 ndr->depth++;
13871                 if (r->in.buffer) {
13872                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13873                 }
13874                 ndr->depth--;
13875                 ndr_print_uint32(ndr, "offered", r->in.offered);
13876                 ndr->depth--;
13877         }
13878         if (flags & NDR_OUT) {
13879                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
13880                 ndr->depth++;
13881                 ndr_print_ptr(ndr, "info", r->out.info);
13882                 ndr->depth++;
13883                 if (r->out.info) {
13884                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
13885                         ndr->depth++;
13886                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
13887                                 char *idx_1=NULL;
13888                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13889                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
13890                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
13891                                         free(idx_1);
13892                                 }
13893                         }
13894                         ndr->depth--;
13895                 }
13896                 ndr->depth--;
13897                 ndr_print_ptr(ndr, "needed", r->out.needed);
13898                 ndr->depth++;
13899                 ndr_print_uint32(ndr, "needed", *r->out.needed);
13900                 ndr->depth--;
13901                 ndr_print_uint32(ndr, "count", r->out.count);
13902                 ndr_print_WERROR(ndr, "result", r->out.result);
13903                 ndr->depth--;
13904         }
13905         ndr->depth--;
13906 }
13907
13908 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
13909 {
13910         if (flags & NDR_IN) {
13911         }
13912         if (flags & NDR_OUT) {
13913                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13914         }
13915         return NDR_ERR_SUCCESS;
13916 }
13917
13918 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
13919 {
13920         if (flags & NDR_IN) {
13921         }
13922         if (flags & NDR_OUT) {
13923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13924         }
13925         return NDR_ERR_SUCCESS;
13926 }
13927
13928 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
13929 {
13930         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
13931         ndr->depth++;
13932         if (flags & NDR_SET_VALUES) {
13933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13934         }
13935         if (flags & NDR_IN) {
13936                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
13937                 ndr->depth++;
13938                 ndr->depth--;
13939         }
13940         if (flags & NDR_OUT) {
13941                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
13942                 ndr->depth++;
13943                 ndr_print_WERROR(ndr, "result", r->out.result);
13944                 ndr->depth--;
13945         }
13946         ndr->depth--;
13947 }
13948
13949 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
13950 {
13951         if (flags & NDR_IN) {
13952                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
13953                 if (r->in.server) {
13954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
13955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
13957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13958                 }
13959                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
13960                 if (r->in.environment) {
13961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
13962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13963                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
13964                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13965                 }
13966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
13968                 if (r->in.buffer) {
13969                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13970                 }
13971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13972         }
13973         if (flags & NDR_OUT) {
13974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13975                 if (r->out.info) {
13976                         {
13977                                 struct ndr_push *_ndr_info;
13978                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
13979                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
13980                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
13981                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
13982                         }
13983                 }
13984                 if (r->out.needed == NULL) {
13985                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13986                 }
13987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
13988                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13989         }
13990         return NDR_ERR_SUCCESS;
13991 }
13992
13993 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
13994 {
13995         uint32_t _ptr_server;
13996         uint32_t _ptr_environment;
13997         uint32_t _ptr_buffer;
13998         uint32_t _ptr_info;
13999         TALLOC_CTX *_mem_save_server_0;
14000         TALLOC_CTX *_mem_save_environment_0;
14001         TALLOC_CTX *_mem_save_buffer_0;
14002         TALLOC_CTX *_mem_save_info_0;
14003         TALLOC_CTX *_mem_save_needed_0;
14004         if (flags & NDR_IN) {
14005                 ZERO_STRUCT(r->out);
14006
14007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14008                 if (_ptr_server) {
14009                         NDR_PULL_ALLOC(ndr, r->in.server);
14010                 } else {
14011                         r->in.server = NULL;
14012                 }
14013                 if (r->in.server) {
14014                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14015                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14018                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14019                                 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));
14020                         }
14021                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14022                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14024                 }
14025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
14026                 if (_ptr_environment) {
14027                         NDR_PULL_ALLOC(ndr, r->in.environment);
14028                 } else {
14029                         r->in.environment = NULL;
14030                 }
14031                 if (r->in.environment) {
14032                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
14033                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
14034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
14035                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
14036                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
14037                                 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));
14038                         }
14039                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
14040                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
14041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
14042                 }
14043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14045                 if (_ptr_buffer) {
14046                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14047                 } else {
14048                         r->in.buffer = NULL;
14049                 }
14050                 if (r->in.buffer) {
14051                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14052                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14053                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14055                 }
14056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14057                 NDR_PULL_ALLOC(ndr, r->out.needed);
14058                 ZERO_STRUCTP(r->out.needed);
14059         }
14060         if (flags & NDR_OUT) {
14061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14062                 if (_ptr_info) {
14063                         NDR_PULL_ALLOC(ndr, r->out.info);
14064                 } else {
14065                         r->out.info = NULL;
14066                 }
14067                 if (r->out.info) {
14068                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14069                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14070                         {
14071                                 struct ndr_pull *_ndr_info;
14072                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
14073                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
14074                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
14075                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
14076                         }
14077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14078                 }
14079                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14080                         NDR_PULL_ALLOC(ndr, r->out.needed);
14081                 }
14082                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14083                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14085                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14087         }
14088         return NDR_ERR_SUCCESS;
14089 }
14090
14091 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
14092 {
14093         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
14094         ndr->depth++;
14095         if (flags & NDR_SET_VALUES) {
14096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14097         }
14098         if (flags & NDR_IN) {
14099                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
14100                 ndr->depth++;
14101                 ndr_print_ptr(ndr, "server", r->in.server);
14102                 ndr->depth++;
14103                 if (r->in.server) {
14104                         ndr_print_string(ndr, "server", r->in.server);
14105                 }
14106                 ndr->depth--;
14107                 ndr_print_ptr(ndr, "environment", r->in.environment);
14108                 ndr->depth++;
14109                 if (r->in.environment) {
14110                         ndr_print_string(ndr, "environment", r->in.environment);
14111                 }
14112                 ndr->depth--;
14113                 ndr_print_uint32(ndr, "level", r->in.level);
14114                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14115                 ndr->depth++;
14116                 if (r->in.buffer) {
14117                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14118                 }
14119                 ndr->depth--;
14120                 ndr_print_uint32(ndr, "offered", r->in.offered);
14121                 ndr->depth--;
14122         }
14123         if (flags & NDR_OUT) {
14124                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
14125                 ndr->depth++;
14126                 ndr_print_ptr(ndr, "info", r->out.info);
14127                 ndr->depth++;
14128                 if (r->out.info) {
14129                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
14130                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
14131                 }
14132                 ndr->depth--;
14133                 ndr_print_ptr(ndr, "needed", r->out.needed);
14134                 ndr->depth++;
14135                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14136                 ndr->depth--;
14137                 ndr_print_WERROR(ndr, "result", r->out.result);
14138                 ndr->depth--;
14139         }
14140         ndr->depth--;
14141 }
14142
14143 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
14144 {
14145         if (flags & NDR_IN) {
14146                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14147                 if (r->in.server) {
14148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14151                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14152                 }
14153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
14154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
14156                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
14158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
14160                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14161         }
14162         if (flags & NDR_OUT) {
14163                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14164         }
14165         return NDR_ERR_SUCCESS;
14166 }
14167
14168 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
14169 {
14170         uint32_t _ptr_server;
14171         TALLOC_CTX *_mem_save_server_0;
14172         if (flags & NDR_IN) {
14173                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14174                 if (_ptr_server) {
14175                         NDR_PULL_ALLOC(ndr, r->in.server);
14176                 } else {
14177                         r->in.server = NULL;
14178                 }
14179                 if (r->in.server) {
14180                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14181                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14182                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14183                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14184                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14185                                 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));
14186                         }
14187                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14188                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14189                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14190                 }
14191                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
14192                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
14193                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
14194                         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));
14195                 }
14196                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
14197                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
14198                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
14199                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
14200                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
14201                         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));
14202                 }
14203                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
14204                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
14205         }
14206         if (flags & NDR_OUT) {
14207                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14208         }
14209         return NDR_ERR_SUCCESS;
14210 }
14211
14212 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
14213 {
14214         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
14215         ndr->depth++;
14216         if (flags & NDR_SET_VALUES) {
14217                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14218         }
14219         if (flags & NDR_IN) {
14220                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
14221                 ndr->depth++;
14222                 ndr_print_ptr(ndr, "server", r->in.server);
14223                 ndr->depth++;
14224                 if (r->in.server) {
14225                         ndr_print_string(ndr, "server", r->in.server);
14226                 }
14227                 ndr->depth--;
14228                 ndr_print_string(ndr, "architecture", r->in.architecture);
14229                 ndr_print_string(ndr, "driver", r->in.driver);
14230                 ndr->depth--;
14231         }
14232         if (flags & NDR_OUT) {
14233                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
14234                 ndr->depth++;
14235                 ndr_print_WERROR(ndr, "result", r->out.result);
14236                 ndr->depth--;
14237         }
14238         ndr->depth--;
14239 }
14240
14241 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
14242 {
14243         if (flags & NDR_IN) {
14244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14245                 if (r->in.server) {
14246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14250                 }
14251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
14252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
14254                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
14256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
14258                 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));
14259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
14260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
14262                 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));
14263         }
14264         if (flags & NDR_OUT) {
14265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14266         }
14267         return NDR_ERR_SUCCESS;
14268 }
14269
14270 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
14271 {
14272         uint32_t _ptr_server;
14273         TALLOC_CTX *_mem_save_server_0;
14274         if (flags & NDR_IN) {
14275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14276                 if (_ptr_server) {
14277                         NDR_PULL_ALLOC(ndr, r->in.server);
14278                 } else {
14279                         r->in.server = NULL;
14280                 }
14281                 if (r->in.server) {
14282                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14283                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14285                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14286                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14287                                 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));
14288                         }
14289                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14290                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14292                 }
14293                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
14294                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
14295                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
14296                         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));
14297                 }
14298                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
14299                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
14300                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
14301                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
14302                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
14303                         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));
14304                 }
14305                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
14306                 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));
14307                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
14308                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
14309                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
14310                         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));
14311                 }
14312                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
14313                 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));
14314         }
14315         if (flags & NDR_OUT) {
14316                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14317         }
14318         return NDR_ERR_SUCCESS;
14319 }
14320
14321 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
14322 {
14323         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
14324         ndr->depth++;
14325         if (flags & NDR_SET_VALUES) {
14326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14327         }
14328         if (flags & NDR_IN) {
14329                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
14330                 ndr->depth++;
14331                 ndr_print_ptr(ndr, "server", r->in.server);
14332                 ndr->depth++;
14333                 if (r->in.server) {
14334                         ndr_print_string(ndr, "server", r->in.server);
14335                 }
14336                 ndr->depth--;
14337                 ndr_print_string(ndr, "architecture", r->in.architecture);
14338                 ndr_print_string(ndr, "path_name", r->in.path_name);
14339                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
14340                 ndr->depth--;
14341         }
14342         if (flags & NDR_OUT) {
14343                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
14344                 ndr->depth++;
14345                 ndr_print_WERROR(ndr, "result", r->out.result);
14346                 ndr->depth--;
14347         }
14348         ndr->depth--;
14349 }
14350
14351 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
14352 {
14353         if (flags & NDR_IN) {
14354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
14355                 if (r->in.servername) {
14356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
14357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
14359                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14360                 }
14361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
14362                 if (r->in.environment) {
14363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
14364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
14366                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14367                 }
14368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14369                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14370                 if (r->in.buffer) {
14371                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14372                 }
14373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14374         }
14375         if (flags & NDR_OUT) {
14376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14377                 if (r->out.info) {
14378                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
14379                 }
14380                 if (r->out.needed == NULL) {
14381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14382                 }
14383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
14385                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14386         }
14387         return NDR_ERR_SUCCESS;
14388 }
14389
14390 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
14391 {
14392         uint32_t _ptr_servername;
14393         uint32_t _ptr_environment;
14394         uint32_t _ptr_buffer;
14395         uint32_t _ptr_info;
14396         TALLOC_CTX *_mem_save_servername_0;
14397         TALLOC_CTX *_mem_save_environment_0;
14398         TALLOC_CTX *_mem_save_buffer_0;
14399         TALLOC_CTX *_mem_save_info_0;
14400         TALLOC_CTX *_mem_save_needed_0;
14401         if (flags & NDR_IN) {
14402                 ZERO_STRUCT(r->out);
14403
14404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
14405                 if (_ptr_servername) {
14406                         NDR_PULL_ALLOC(ndr, r->in.servername);
14407                 } else {
14408                         r->in.servername = NULL;
14409                 }
14410                 if (r->in.servername) {
14411                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
14412                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
14413                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
14414                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
14415                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
14416                                 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));
14417                         }
14418                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
14419                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
14420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
14421                 }
14422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
14423                 if (_ptr_environment) {
14424                         NDR_PULL_ALLOC(ndr, r->in.environment);
14425                 } else {
14426                         r->in.environment = NULL;
14427                 }
14428                 if (r->in.environment) {
14429                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
14430                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
14431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
14432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
14433                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
14434                                 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));
14435                         }
14436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
14437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
14438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
14439                 }
14440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14442                 if (_ptr_buffer) {
14443                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14444                 } else {
14445                         r->in.buffer = NULL;
14446                 }
14447                 if (r->in.buffer) {
14448                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14449                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14450                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14452                 }
14453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14454                 NDR_PULL_ALLOC(ndr, r->out.needed);
14455                 ZERO_STRUCTP(r->out.needed);
14456         }
14457         if (flags & NDR_OUT) {
14458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14459                 if (_ptr_info) {
14460                         NDR_PULL_ALLOC(ndr, r->out.info);
14461                 } else {
14462                         r->out.info = NULL;
14463                 }
14464                 if (r->out.info) {
14465                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14466                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14467                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
14468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14469                 }
14470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14471                         NDR_PULL_ALLOC(ndr, r->out.needed);
14472                 }
14473                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14474                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14475                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
14478                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14479         }
14480         return NDR_ERR_SUCCESS;
14481 }
14482
14483 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
14484 {
14485         uint32_t cntr_info_0;
14486         if (flags & NDR_IN) {
14487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
14489         }
14490         if (flags & NDR_OUT) {
14491                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14492                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14493                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14494                 }
14495                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14496                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14497                 }
14498         }
14499         return NDR_ERR_SUCCESS;
14500 }
14501
14502 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
14503 {
14504         uint32_t cntr_info_0;
14505         TALLOC_CTX *_mem_save_info_0;
14506         if (flags & NDR_IN) {
14507                 ZERO_STRUCT(r->out);
14508
14509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
14511         }
14512         if (flags & NDR_OUT) {
14513                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
14514                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14515                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14516                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14517                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14518                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14519                 }
14520                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14521                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14522                 }
14523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14524         }
14525         return NDR_ERR_SUCCESS;
14526 }
14527
14528 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
14529 {
14530         uint32_t cntr_info_1;
14531         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
14532         ndr->depth++;
14533         if (flags & NDR_SET_VALUES) {
14534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14535         }
14536         if (flags & NDR_IN) {
14537                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
14538                 ndr->depth++;
14539                 ndr_print_ptr(ndr, "servername", r->in.servername);
14540                 ndr->depth++;
14541                 if (r->in.servername) {
14542                         ndr_print_string(ndr, "servername", r->in.servername);
14543                 }
14544                 ndr->depth--;
14545                 ndr_print_ptr(ndr, "environment", r->in.environment);
14546                 ndr->depth++;
14547                 if (r->in.environment) {
14548                         ndr_print_string(ndr, "environment", r->in.environment);
14549                 }
14550                 ndr->depth--;
14551                 ndr_print_uint32(ndr, "level", r->in.level);
14552                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14553                 ndr->depth++;
14554                 if (r->in.buffer) {
14555                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14556                 }
14557                 ndr->depth--;
14558                 ndr_print_uint32(ndr, "offered", r->in.offered);
14559                 ndr->depth--;
14560         }
14561         if (flags & NDR_OUT) {
14562                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
14563                 ndr->depth++;
14564                 ndr_print_ptr(ndr, "info", r->out.info);
14565                 ndr->depth++;
14566                 if (r->out.info) {
14567                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
14568                         ndr->depth++;
14569                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
14570                                 char *idx_1=NULL;
14571                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
14572                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
14573                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
14574                                         free(idx_1);
14575                                 }
14576                         }
14577                         ndr->depth--;
14578                 }
14579                 ndr->depth--;
14580                 ndr_print_ptr(ndr, "needed", r->out.needed);
14581                 ndr->depth++;
14582                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14583                 ndr->depth--;
14584                 ndr_print_uint32(ndr, "count", r->out.count);
14585                 ndr_print_WERROR(ndr, "result", r->out.result);
14586                 ndr->depth--;
14587         }
14588         ndr->depth--;
14589 }
14590
14591 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
14592 {
14593         if (flags & NDR_IN) {
14594         }
14595         if (flags & NDR_OUT) {
14596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14597         }
14598         return NDR_ERR_SUCCESS;
14599 }
14600
14601 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
14602 {
14603         if (flags & NDR_IN) {
14604         }
14605         if (flags & NDR_OUT) {
14606                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14607         }
14608         return NDR_ERR_SUCCESS;
14609 }
14610
14611 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
14612 {
14613         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
14614         ndr->depth++;
14615         if (flags & NDR_SET_VALUES) {
14616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14617         }
14618         if (flags & NDR_IN) {
14619                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
14620                 ndr->depth++;
14621                 ndr->depth--;
14622         }
14623         if (flags & NDR_OUT) {
14624                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
14625                 ndr->depth++;
14626                 ndr_print_WERROR(ndr, "result", r->out.result);
14627                 ndr->depth--;
14628         }
14629         ndr->depth--;
14630 }
14631
14632 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
14633 {
14634         if (flags & NDR_IN) {
14635                 if (r->in.handle == NULL) {
14636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14637                 }
14638                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14640                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
14641                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
14642         }
14643         if (flags & NDR_OUT) {
14644                 if (r->out.job_id == NULL) {
14645                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14646                 }
14647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
14648                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14649         }
14650         return NDR_ERR_SUCCESS;
14651 }
14652
14653 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
14654 {
14655         TALLOC_CTX *_mem_save_handle_0;
14656         TALLOC_CTX *_mem_save_job_id_0;
14657         if (flags & NDR_IN) {
14658                 ZERO_STRUCT(r->out);
14659
14660                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14661                         NDR_PULL_ALLOC(ndr, r->in.handle);
14662                 }
14663                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14664                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14665                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14666                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14668                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
14669                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
14670                 NDR_PULL_ALLOC(ndr, r->out.job_id);
14671                 ZERO_STRUCTP(r->out.job_id);
14672         }
14673         if (flags & NDR_OUT) {
14674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14675                         NDR_PULL_ALLOC(ndr, r->out.job_id);
14676                 }
14677                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
14679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
14680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
14681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14682         }
14683         return NDR_ERR_SUCCESS;
14684 }
14685
14686 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
14687 {
14688         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
14689         ndr->depth++;
14690         if (flags & NDR_SET_VALUES) {
14691                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14692         }
14693         if (flags & NDR_IN) {
14694                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
14695                 ndr->depth++;
14696                 ndr_print_ptr(ndr, "handle", r->in.handle);
14697                 ndr->depth++;
14698                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14699                 ndr->depth--;
14700                 ndr_print_uint32(ndr, "level", r->in.level);
14701                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
14702                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
14703                 ndr->depth--;
14704         }
14705         if (flags & NDR_OUT) {
14706                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
14707                 ndr->depth++;
14708                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
14709                 ndr->depth++;
14710                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
14711                 ndr->depth--;
14712                 ndr_print_WERROR(ndr, "result", r->out.result);
14713                 ndr->depth--;
14714         }
14715         ndr->depth--;
14716 }
14717
14718 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
14719 {
14720         if (flags & NDR_IN) {
14721                 if (r->in.handle == NULL) {
14722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14723                 }
14724                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14725         }
14726         if (flags & NDR_OUT) {
14727                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14728         }
14729         return NDR_ERR_SUCCESS;
14730 }
14731
14732 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
14733 {
14734         TALLOC_CTX *_mem_save_handle_0;
14735         if (flags & NDR_IN) {
14736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14737                         NDR_PULL_ALLOC(ndr, r->in.handle);
14738                 }
14739                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14741                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14743         }
14744         if (flags & NDR_OUT) {
14745                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14746         }
14747         return NDR_ERR_SUCCESS;
14748 }
14749
14750 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
14751 {
14752         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
14753         ndr->depth++;
14754         if (flags & NDR_SET_VALUES) {
14755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14756         }
14757         if (flags & NDR_IN) {
14758                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
14759                 ndr->depth++;
14760                 ndr_print_ptr(ndr, "handle", r->in.handle);
14761                 ndr->depth++;
14762                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14763                 ndr->depth--;
14764                 ndr->depth--;
14765         }
14766         if (flags & NDR_OUT) {
14767                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
14768                 ndr->depth++;
14769                 ndr_print_WERROR(ndr, "result", r->out.result);
14770                 ndr->depth--;
14771         }
14772         ndr->depth--;
14773 }
14774
14775 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
14776 {
14777         if (flags & NDR_IN) {
14778                 if (r->in.handle == NULL) {
14779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14780                 }
14781                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14782                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
14783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
14784         }
14785         if (flags & NDR_OUT) {
14786                 if (r->out.num_written == NULL) {
14787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14788                 }
14789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
14790                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14791         }
14792         return NDR_ERR_SUCCESS;
14793 }
14794
14795 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
14796 {
14797         TALLOC_CTX *_mem_save_handle_0;
14798         TALLOC_CTX *_mem_save_num_written_0;
14799         if (flags & NDR_IN) {
14800                 ZERO_STRUCT(r->out);
14801
14802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14803                         NDR_PULL_ALLOC(ndr, r->in.handle);
14804                 }
14805                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14806                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14807                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14809                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
14810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
14811                 NDR_PULL_ALLOC(ndr, r->out.num_written);
14812                 ZERO_STRUCTP(r->out.num_written);
14813         }
14814         if (flags & NDR_OUT) {
14815                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14816                         NDR_PULL_ALLOC(ndr, r->out.num_written);
14817                 }
14818                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
14819                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
14820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
14821                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
14822                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14823         }
14824         return NDR_ERR_SUCCESS;
14825 }
14826
14827 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
14828 {
14829         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
14830         ndr->depth++;
14831         if (flags & NDR_SET_VALUES) {
14832                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14833         }
14834         if (flags & NDR_IN) {
14835                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
14836                 ndr->depth++;
14837                 ndr_print_ptr(ndr, "handle", r->in.handle);
14838                 ndr->depth++;
14839                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14840                 ndr->depth--;
14841                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
14842                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
14843                 ndr->depth--;
14844         }
14845         if (flags & NDR_OUT) {
14846                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
14847                 ndr->depth++;
14848                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
14849                 ndr->depth++;
14850                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
14851                 ndr->depth--;
14852                 ndr_print_WERROR(ndr, "result", r->out.result);
14853                 ndr->depth--;
14854         }
14855         ndr->depth--;
14856 }
14857
14858 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
14859 {
14860         if (flags & NDR_IN) {
14861                 if (r->in.handle == NULL) {
14862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14863                 }
14864                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14865         }
14866         if (flags & NDR_OUT) {
14867                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14868         }
14869         return NDR_ERR_SUCCESS;
14870 }
14871
14872 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
14873 {
14874         TALLOC_CTX *_mem_save_handle_0;
14875         if (flags & NDR_IN) {
14876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14877                         NDR_PULL_ALLOC(ndr, r->in.handle);
14878                 }
14879                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14880                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14881                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14883         }
14884         if (flags & NDR_OUT) {
14885                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14886         }
14887         return NDR_ERR_SUCCESS;
14888 }
14889
14890 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
14891 {
14892         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
14893         ndr->depth++;
14894         if (flags & NDR_SET_VALUES) {
14895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14896         }
14897         if (flags & NDR_IN) {
14898                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
14899                 ndr->depth++;
14900                 ndr_print_ptr(ndr, "handle", r->in.handle);
14901                 ndr->depth++;
14902                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14903                 ndr->depth--;
14904                 ndr->depth--;
14905         }
14906         if (flags & NDR_OUT) {
14907                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
14908                 ndr->depth++;
14909                 ndr_print_WERROR(ndr, "result", r->out.result);
14910                 ndr->depth--;
14911         }
14912         ndr->depth--;
14913 }
14914
14915 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
14916 {
14917         if (flags & NDR_IN) {
14918                 if (r->in.handle == NULL) {
14919                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14920                 }
14921                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14922         }
14923         if (flags & NDR_OUT) {
14924                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14925         }
14926         return NDR_ERR_SUCCESS;
14927 }
14928
14929 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
14930 {
14931         TALLOC_CTX *_mem_save_handle_0;
14932         if (flags & NDR_IN) {
14933                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14934                         NDR_PULL_ALLOC(ndr, r->in.handle);
14935                 }
14936                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14937                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14938                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14939                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14940         }
14941         if (flags & NDR_OUT) {
14942                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14943         }
14944         return NDR_ERR_SUCCESS;
14945 }
14946
14947 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
14948 {
14949         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
14950         ndr->depth++;
14951         if (flags & NDR_SET_VALUES) {
14952                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14953         }
14954         if (flags & NDR_IN) {
14955                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
14956                 ndr->depth++;
14957                 ndr_print_ptr(ndr, "handle", r->in.handle);
14958                 ndr->depth++;
14959                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14960                 ndr->depth--;
14961                 ndr->depth--;
14962         }
14963         if (flags & NDR_OUT) {
14964                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
14965                 ndr->depth++;
14966                 ndr_print_WERROR(ndr, "result", r->out.result);
14967                 ndr->depth--;
14968         }
14969         ndr->depth--;
14970 }
14971
14972 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
14973 {
14974         if (flags & NDR_IN) {
14975                 if (r->in.handle == NULL) {
14976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14977                 }
14978                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
14980         }
14981         if (flags & NDR_OUT) {
14982                 if (r->out.data == NULL) {
14983                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14984                 }
14985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
14986                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
14987                 if (r->out._data_size == NULL) {
14988                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14989                 }
14990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
14991                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14992         }
14993         return NDR_ERR_SUCCESS;
14994 }
14995
14996 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
14997 {
14998         TALLOC_CTX *_mem_save_handle_0;
14999         TALLOC_CTX *_mem_save__data_size_0;
15000         if (flags & NDR_IN) {
15001                 ZERO_STRUCT(r->out);
15002
15003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15004                         NDR_PULL_ALLOC(ndr, r->in.handle);
15005                 }
15006                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15007                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15008                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
15011                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
15012                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
15013                 NDR_PULL_ALLOC(ndr, r->out._data_size);
15014                 ZERO_STRUCTP(r->out._data_size);
15015         }
15016         if (flags & NDR_OUT) {
15017                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
15018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15019                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
15020                 }
15021                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
15022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15023                         NDR_PULL_ALLOC(ndr, r->out._data_size);
15024                 }
15025                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
15026                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
15027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
15028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
15029                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15030                 if (r->out.data) {
15031                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
15032                 }
15033         }
15034         return NDR_ERR_SUCCESS;
15035 }
15036
15037 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
15038 {
15039         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
15040         ndr->depth++;
15041         if (flags & NDR_SET_VALUES) {
15042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15043         }
15044         if (flags & NDR_IN) {
15045                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
15046                 ndr->depth++;
15047                 ndr_print_ptr(ndr, "handle", r->in.handle);
15048                 ndr->depth++;
15049                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15050                 ndr->depth--;
15051                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
15052                 ndr->depth--;
15053         }
15054         if (flags & NDR_OUT) {
15055                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
15056                 ndr->depth++;
15057                 ndr_print_ptr(ndr, "data", r->out.data);
15058                 ndr->depth++;
15059                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
15060                 ndr->depth--;
15061                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
15062                 ndr->depth++;
15063                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
15064                 ndr->depth--;
15065                 ndr_print_WERROR(ndr, "result", r->out.result);
15066                 ndr->depth--;
15067         }
15068         ndr->depth--;
15069 }
15070
15071 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
15072 {
15073         if (flags & NDR_IN) {
15074                 if (r->in.handle == NULL) {
15075                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15076                 }
15077                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15078         }
15079         if (flags & NDR_OUT) {
15080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15081         }
15082         return NDR_ERR_SUCCESS;
15083 }
15084
15085 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
15086 {
15087         TALLOC_CTX *_mem_save_handle_0;
15088         if (flags & NDR_IN) {
15089                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15090                         NDR_PULL_ALLOC(ndr, r->in.handle);
15091                 }
15092                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15093                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15094                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15095                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15096         }
15097         if (flags & NDR_OUT) {
15098                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15099         }
15100         return NDR_ERR_SUCCESS;
15101 }
15102
15103 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
15104 {
15105         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
15106         ndr->depth++;
15107         if (flags & NDR_SET_VALUES) {
15108                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15109         }
15110         if (flags & NDR_IN) {
15111                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
15112                 ndr->depth++;
15113                 ndr_print_ptr(ndr, "handle", r->in.handle);
15114                 ndr->depth++;
15115                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15116                 ndr->depth--;
15117                 ndr->depth--;
15118         }
15119         if (flags & NDR_OUT) {
15120                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
15121                 ndr->depth++;
15122                 ndr_print_WERROR(ndr, "result", r->out.result);
15123                 ndr->depth--;
15124         }
15125         ndr->depth--;
15126 }
15127
15128 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
15129 {
15130         if (flags & NDR_IN) {
15131                 if (r->in.handle == NULL) {
15132                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15133                 }
15134                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15137                 if (r->in.buffer) {
15138                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15139                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
15140                 }
15141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15142         }
15143         if (flags & NDR_OUT) {
15144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
15145                 if (r->out.buffer) {
15146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15147                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
15148                 }
15149                 if (r->out.needed == NULL) {
15150                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15151                 }
15152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15154         }
15155         return NDR_ERR_SUCCESS;
15156 }
15157
15158 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
15159 {
15160         uint32_t _ptr_buffer;
15161         TALLOC_CTX *_mem_save_handle_0;
15162         TALLOC_CTX *_mem_save_buffer_0;
15163         TALLOC_CTX *_mem_save_needed_0;
15164         if (flags & NDR_IN) {
15165                 ZERO_STRUCT(r->out);
15166
15167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15168                         NDR_PULL_ALLOC(ndr, r->in.handle);
15169                 }
15170                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15171                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15172                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15176                 if (_ptr_buffer) {
15177                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15178                 } else {
15179                         r->in.buffer = NULL;
15180                 }
15181                 if (r->in.buffer) {
15182                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15183                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
15185                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
15186                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
15187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15188                 }
15189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15190                 NDR_PULL_ALLOC(ndr, r->out.needed);
15191                 ZERO_STRUCTP(r->out.needed);
15192                 if (r->in.buffer) {
15193                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
15194                 }
15195         }
15196         if (flags & NDR_OUT) {
15197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15198                 if (_ptr_buffer) {
15199                         NDR_PULL_ALLOC(ndr, r->out.buffer);
15200                 } else {
15201                         r->out.buffer = NULL;
15202                 }
15203                 if (r->out.buffer) {
15204                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15205                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
15206                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
15207                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
15208                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
15209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15210                 }
15211                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15212                         NDR_PULL_ALLOC(ndr, r->out.needed);
15213                 }
15214                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15215                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15217                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15219                 if (r->out.buffer) {
15220                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
15221                 }
15222         }
15223         return NDR_ERR_SUCCESS;
15224 }
15225
15226 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
15227 {
15228         ndr_print_struct(ndr, name, "spoolss_AddJob");
15229         ndr->depth++;
15230         if (flags & NDR_SET_VALUES) {
15231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15232         }
15233         if (flags & NDR_IN) {
15234                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
15235                 ndr->depth++;
15236                 ndr_print_ptr(ndr, "handle", r->in.handle);
15237                 ndr->depth++;
15238                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15239                 ndr->depth--;
15240                 ndr_print_uint32(ndr, "level", r->in.level);
15241                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15242                 ndr->depth++;
15243                 if (r->in.buffer) {
15244                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
15245                 }
15246                 ndr->depth--;
15247                 ndr_print_uint32(ndr, "offered", r->in.offered);
15248                 ndr->depth--;
15249         }
15250         if (flags & NDR_OUT) {
15251                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
15252                 ndr->depth++;
15253                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
15254                 ndr->depth++;
15255                 if (r->out.buffer) {
15256                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
15257                 }
15258                 ndr->depth--;
15259                 ndr_print_ptr(ndr, "needed", r->out.needed);
15260                 ndr->depth++;
15261                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15262                 ndr->depth--;
15263                 ndr_print_WERROR(ndr, "result", r->out.result);
15264                 ndr->depth--;
15265         }
15266         ndr->depth--;
15267 }
15268
15269 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
15270 {
15271         if (flags & NDR_IN) {
15272                 if (r->in.handle == NULL) {
15273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15274                 }
15275                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
15277         }
15278         if (flags & NDR_OUT) {
15279                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15280         }
15281         return NDR_ERR_SUCCESS;
15282 }
15283
15284 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
15285 {
15286         TALLOC_CTX *_mem_save_handle_0;
15287         if (flags & NDR_IN) {
15288                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15289                         NDR_PULL_ALLOC(ndr, r->in.handle);
15290                 }
15291                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15292                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15293                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
15296         }
15297         if (flags & NDR_OUT) {
15298                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15299         }
15300         return NDR_ERR_SUCCESS;
15301 }
15302
15303 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
15304 {
15305         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
15306         ndr->depth++;
15307         if (flags & NDR_SET_VALUES) {
15308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15309         }
15310         if (flags & NDR_IN) {
15311                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
15312                 ndr->depth++;
15313                 ndr_print_ptr(ndr, "handle", r->in.handle);
15314                 ndr->depth++;
15315                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15316                 ndr->depth--;
15317                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
15318                 ndr->depth--;
15319         }
15320         if (flags & NDR_OUT) {
15321                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
15322                 ndr->depth++;
15323                 ndr_print_WERROR(ndr, "result", r->out.result);
15324                 ndr->depth--;
15325         }
15326         ndr->depth--;
15327 }
15328
15329 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
15330 {
15331         if (flags & NDR_IN) {
15332                 if (r->in.handle == NULL) {
15333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15334                 }
15335                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15339                 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));
15340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15341         }
15342         if (flags & NDR_OUT) {
15343                 if (r->out.type == NULL) {
15344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15345                 }
15346                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
15347                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
15348                 if (r->out.needed == NULL) {
15349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15350                 }
15351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15353         }
15354         return NDR_ERR_SUCCESS;
15355 }
15356
15357 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
15358 {
15359         TALLOC_CTX *_mem_save_handle_0;
15360         TALLOC_CTX *_mem_save_type_0;
15361         TALLOC_CTX *_mem_save_needed_0;
15362         if (flags & NDR_IN) {
15363                 ZERO_STRUCT(r->out);
15364
15365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15366                         NDR_PULL_ALLOC(ndr, r->in.handle);
15367                 }
15368                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15370                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15372                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15373                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15374                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15375                         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));
15376                 }
15377                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15378                 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));
15379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15380                 NDR_PULL_ALLOC(ndr, r->out.type);
15381                 ZERO_STRUCTP(r->out.type);
15382                 NDR_PULL_ALLOC(ndr, r->out.needed);
15383                 ZERO_STRUCTP(r->out.needed);
15384         }
15385         if (flags & NDR_OUT) {
15386                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15387                         NDR_PULL_ALLOC(ndr, r->out.type);
15388                 }
15389                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15390                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
15391                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
15392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
15393                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
15394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15395                         NDR_PULL_ALLOC(ndr, r->out.needed);
15396                 }
15397                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15398                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15400                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15401                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15402         }
15403         return NDR_ERR_SUCCESS;
15404 }
15405
15406 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
15407 {
15408         if (flags & NDR_IN) {
15409                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
15410         }
15411         if (flags & NDR_OUT) {
15412                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
15413                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
15414         }
15415         return NDR_ERR_SUCCESS;
15416 }
15417
15418 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
15419 {
15420         if (flags & NDR_IN) {
15421                 ZERO_STRUCT(r->out);
15422
15423                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
15424         }
15425         if (flags & NDR_OUT) {
15426                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
15427                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
15428         }
15429         return NDR_ERR_SUCCESS;
15430 }
15431
15432 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
15433 {
15434         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
15435         ndr->depth++;
15436         if (flags & NDR_SET_VALUES) {
15437                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15438         }
15439         if (flags & NDR_IN) {
15440                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
15441                 ndr->depth++;
15442                 ndr_print_ptr(ndr, "handle", r->in.handle);
15443                 ndr->depth++;
15444                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15445                 ndr->depth--;
15446                 ndr_print_string(ndr, "value_name", r->in.value_name);
15447                 ndr_print_uint32(ndr, "offered", r->in.offered);
15448                 ndr->depth--;
15449         }
15450         if (flags & NDR_OUT) {
15451                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
15452                 ndr->depth++;
15453                 ndr_print_ptr(ndr, "type", r->out.type);
15454                 ndr->depth++;
15455                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
15456                 ndr->depth--;
15457                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
15458                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
15459                 ndr_print_ptr(ndr, "needed", r->out.needed);
15460                 ndr->depth++;
15461                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15462                 ndr->depth--;
15463                 ndr_print_WERROR(ndr, "result", r->out.result);
15464                 ndr->depth--;
15465         }
15466         ndr->depth--;
15467 }
15468
15469 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
15470 {
15471         if (flags & NDR_IN) {
15472                 if (r->in.handle == NULL) {
15473                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15474                 }
15475                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15479                 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));
15480                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
15481                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
15482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
15483         }
15484         if (flags & NDR_OUT) {
15485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15486         }
15487         return NDR_ERR_SUCCESS;
15488 }
15489
15490 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
15491 {
15492         if (flags & NDR_IN) {
15493                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
15494         }
15495         if (flags & NDR_OUT) {
15496                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
15497                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
15498         }
15499         return NDR_ERR_SUCCESS;
15500 }
15501
15502 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
15503 {
15504         TALLOC_CTX *_mem_save_handle_0;
15505         if (flags & NDR_IN) {
15506                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15507                         NDR_PULL_ALLOC(ndr, r->in.handle);
15508                 }
15509                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15510                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15511                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15513                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15514                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15515                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15516                         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));
15517                 }
15518                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15519                 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));
15520                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
15521                 {
15522                         struct ndr_pull *_ndr_data;
15523                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
15524                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
15525                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
15526                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
15527                 }
15528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
15529         }
15530         if (flags & NDR_OUT) {
15531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15532         }
15533         return NDR_ERR_SUCCESS;
15534 }
15535
15536 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
15537 {
15538         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
15539         ndr->depth++;
15540         if (flags & NDR_SET_VALUES) {
15541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15542         }
15543         if (flags & NDR_IN) {
15544                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
15545                 ndr->depth++;
15546                 ndr_print_ptr(ndr, "handle", r->in.handle);
15547                 ndr->depth++;
15548                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15549                 ndr->depth--;
15550                 ndr_print_string(ndr, "value_name", r->in.value_name);
15551                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
15552                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
15553                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
15554                 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);
15555                 ndr->depth--;
15556         }
15557         if (flags & NDR_OUT) {
15558                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
15559                 ndr->depth++;
15560                 ndr_print_WERROR(ndr, "result", r->out.result);
15561                 ndr->depth--;
15562         }
15563         ndr->depth--;
15564 }
15565
15566 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
15567 {
15568         if (flags & NDR_IN) {
15569         }
15570         if (flags & NDR_OUT) {
15571                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15572         }
15573         return NDR_ERR_SUCCESS;
15574 }
15575
15576 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
15577 {
15578         if (flags & NDR_IN) {
15579         }
15580         if (flags & NDR_OUT) {
15581                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15582         }
15583         return NDR_ERR_SUCCESS;
15584 }
15585
15586 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
15587 {
15588         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
15589         ndr->depth++;
15590         if (flags & NDR_SET_VALUES) {
15591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15592         }
15593         if (flags & NDR_IN) {
15594                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
15595                 ndr->depth++;
15596                 ndr->depth--;
15597         }
15598         if (flags & NDR_OUT) {
15599                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
15600                 ndr->depth++;
15601                 ndr_print_WERROR(ndr, "result", r->out.result);
15602                 ndr->depth--;
15603         }
15604         ndr->depth--;
15605 }
15606
15607 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
15608 {
15609         if (flags & NDR_IN) {
15610                 if (r->in.handle == NULL) {
15611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15612                 }
15613                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15614         }
15615         if (flags & NDR_OUT) {
15616                 if (r->out.handle == NULL) {
15617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15618                 }
15619                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15621         }
15622         return NDR_ERR_SUCCESS;
15623 }
15624
15625 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
15626 {
15627         TALLOC_CTX *_mem_save_handle_0;
15628         if (flags & NDR_IN) {
15629                 ZERO_STRUCT(r->out);
15630
15631                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15632                         NDR_PULL_ALLOC(ndr, r->in.handle);
15633                 }
15634                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15635                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15636                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15638                 NDR_PULL_ALLOC(ndr, r->out.handle);
15639                 *r->out.handle = *r->in.handle;
15640         }
15641         if (flags & NDR_OUT) {
15642                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15643                         NDR_PULL_ALLOC(ndr, r->out.handle);
15644                 }
15645                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15646                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
15647                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15648                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15649                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15650         }
15651         return NDR_ERR_SUCCESS;
15652 }
15653
15654 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
15655 {
15656         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
15657         ndr->depth++;
15658         if (flags & NDR_SET_VALUES) {
15659                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15660         }
15661         if (flags & NDR_IN) {
15662                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
15663                 ndr->depth++;
15664                 ndr_print_ptr(ndr, "handle", r->in.handle);
15665                 ndr->depth++;
15666                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15667                 ndr->depth--;
15668                 ndr->depth--;
15669         }
15670         if (flags & NDR_OUT) {
15671                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
15672                 ndr->depth++;
15673                 ndr_print_ptr(ndr, "handle", r->out.handle);
15674                 ndr->depth++;
15675                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
15676                 ndr->depth--;
15677                 ndr_print_WERROR(ndr, "result", r->out.result);
15678                 ndr->depth--;
15679         }
15680         ndr->depth--;
15681 }
15682
15683 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
15684 {
15685         if (flags & NDR_IN) {
15686                 if (r->in.handle == NULL) {
15687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15688                 }
15689                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15691                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
15692                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
15693         }
15694         if (flags & NDR_OUT) {
15695                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15696         }
15697         return NDR_ERR_SUCCESS;
15698 }
15699
15700 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
15701 {
15702         TALLOC_CTX *_mem_save_handle_0;
15703         if (flags & NDR_IN) {
15704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15705                         NDR_PULL_ALLOC(ndr, r->in.handle);
15706                 }
15707                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15708                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15709                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15712                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
15713                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
15714         }
15715         if (flags & NDR_OUT) {
15716                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15717         }
15718         return NDR_ERR_SUCCESS;
15719 }
15720
15721 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
15722 {
15723         ndr_print_struct(ndr, name, "spoolss_AddForm");
15724         ndr->depth++;
15725         if (flags & NDR_SET_VALUES) {
15726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15727         }
15728         if (flags & NDR_IN) {
15729                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
15730                 ndr->depth++;
15731                 ndr_print_ptr(ndr, "handle", r->in.handle);
15732                 ndr->depth++;
15733                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15734                 ndr->depth--;
15735                 ndr_print_uint32(ndr, "level", r->in.level);
15736                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
15737                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
15738                 ndr->depth--;
15739         }
15740         if (flags & NDR_OUT) {
15741                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
15742                 ndr->depth++;
15743                 ndr_print_WERROR(ndr, "result", r->out.result);
15744                 ndr->depth--;
15745         }
15746         ndr->depth--;
15747 }
15748
15749 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
15750 {
15751         if (flags & NDR_IN) {
15752                 if (r->in.handle == NULL) {
15753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15754                 }
15755                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
15757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
15759                 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));
15760         }
15761         if (flags & NDR_OUT) {
15762                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15763         }
15764         return NDR_ERR_SUCCESS;
15765 }
15766
15767 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
15768 {
15769         TALLOC_CTX *_mem_save_handle_0;
15770         if (flags & NDR_IN) {
15771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15772                         NDR_PULL_ALLOC(ndr, r->in.handle);
15773                 }
15774                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15775                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15776                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15778                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
15779                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
15780                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
15781                         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));
15782                 }
15783                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
15784                 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));
15785         }
15786         if (flags & NDR_OUT) {
15787                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15788         }
15789         return NDR_ERR_SUCCESS;
15790 }
15791
15792 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
15793 {
15794         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
15795         ndr->depth++;
15796         if (flags & NDR_SET_VALUES) {
15797                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15798         }
15799         if (flags & NDR_IN) {
15800                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
15801                 ndr->depth++;
15802                 ndr_print_ptr(ndr, "handle", r->in.handle);
15803                 ndr->depth++;
15804                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15805                 ndr->depth--;
15806                 ndr_print_string(ndr, "form_name", r->in.form_name);
15807                 ndr->depth--;
15808         }
15809         if (flags & NDR_OUT) {
15810                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
15811                 ndr->depth++;
15812                 ndr_print_WERROR(ndr, "result", r->out.result);
15813                 ndr->depth--;
15814         }
15815         ndr->depth--;
15816 }
15817
15818 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
15819 {
15820         if (flags & NDR_IN) {
15821                 if (r->in.handle == NULL) {
15822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15823                 }
15824                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
15826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
15828                 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));
15829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15831                 if (r->in.buffer) {
15832                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15833                 }
15834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15835         }
15836         if (flags & NDR_OUT) {
15837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15838                 if (r->out.info) {
15839                         {
15840                                 struct ndr_push *_ndr_info;
15841                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15842                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15843                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15844                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15845                         }
15846                 }
15847                 if (r->out.needed == NULL) {
15848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15849                 }
15850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15851                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15852         }
15853         return NDR_ERR_SUCCESS;
15854 }
15855
15856 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
15857 {
15858         uint32_t _ptr_buffer;
15859         uint32_t _ptr_info;
15860         TALLOC_CTX *_mem_save_handle_0;
15861         TALLOC_CTX *_mem_save_buffer_0;
15862         TALLOC_CTX *_mem_save_info_0;
15863         TALLOC_CTX *_mem_save_needed_0;
15864         if (flags & NDR_IN) {
15865                 ZERO_STRUCT(r->out);
15866
15867                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15868                         NDR_PULL_ALLOC(ndr, r->in.handle);
15869                 }
15870                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15871                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15872                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15873                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15874                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
15875                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
15876                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
15877                         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));
15878                 }
15879                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
15880                 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));
15881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15883                 if (_ptr_buffer) {
15884                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15885                 } else {
15886                         r->in.buffer = NULL;
15887                 }
15888                 if (r->in.buffer) {
15889                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15890                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15891                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15893                 }
15894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15895                 NDR_PULL_ALLOC(ndr, r->out.needed);
15896                 ZERO_STRUCTP(r->out.needed);
15897         }
15898         if (flags & NDR_OUT) {
15899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15900                 if (_ptr_info) {
15901                         NDR_PULL_ALLOC(ndr, r->out.info);
15902                 } else {
15903                         r->out.info = NULL;
15904                 }
15905                 if (r->out.info) {
15906                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15907                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15908                         {
15909                                 struct ndr_pull *_ndr_info;
15910                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15911                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15912                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15913                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15914                         }
15915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15916                 }
15917                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15918                         NDR_PULL_ALLOC(ndr, r->out.needed);
15919                 }
15920                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15921                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15924                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15925         }
15926         return NDR_ERR_SUCCESS;
15927 }
15928
15929 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
15930 {
15931         ndr_print_struct(ndr, name, "spoolss_GetForm");
15932         ndr->depth++;
15933         if (flags & NDR_SET_VALUES) {
15934                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15935         }
15936         if (flags & NDR_IN) {
15937                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
15938                 ndr->depth++;
15939                 ndr_print_ptr(ndr, "handle", r->in.handle);
15940                 ndr->depth++;
15941                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15942                 ndr->depth--;
15943                 ndr_print_string(ndr, "form_name", r->in.form_name);
15944                 ndr_print_uint32(ndr, "level", r->in.level);
15945                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15946                 ndr->depth++;
15947                 if (r->in.buffer) {
15948                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15949                 }
15950                 ndr->depth--;
15951                 ndr_print_uint32(ndr, "offered", r->in.offered);
15952                 ndr->depth--;
15953         }
15954         if (flags & NDR_OUT) {
15955                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
15956                 ndr->depth++;
15957                 ndr_print_ptr(ndr, "info", r->out.info);
15958                 ndr->depth++;
15959                 if (r->out.info) {
15960                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15961                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
15962                 }
15963                 ndr->depth--;
15964                 ndr_print_ptr(ndr, "needed", r->out.needed);
15965                 ndr->depth++;
15966                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15967                 ndr->depth--;
15968                 ndr_print_WERROR(ndr, "result", r->out.result);
15969                 ndr->depth--;
15970         }
15971         ndr->depth--;
15972 }
15973
15974 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
15975 {
15976         if (flags & NDR_IN) {
15977                 if (r->in.handle == NULL) {
15978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15979                 }
15980                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
15982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
15984                 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));
15985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15986                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
15987                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
15988         }
15989         if (flags & NDR_OUT) {
15990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15991         }
15992         return NDR_ERR_SUCCESS;
15993 }
15994
15995 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
15996 {
15997         TALLOC_CTX *_mem_save_handle_0;
15998         if (flags & NDR_IN) {
15999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16000                         NDR_PULL_ALLOC(ndr, r->in.handle);
16001                 }
16002                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16004                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16006                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
16007                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
16008                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
16009                         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));
16010                 }
16011                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
16012                 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));
16013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16014                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
16015                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16016         }
16017         if (flags & NDR_OUT) {
16018                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16019         }
16020         return NDR_ERR_SUCCESS;
16021 }
16022
16023 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
16024 {
16025         ndr_print_struct(ndr, name, "spoolss_SetForm");
16026         ndr->depth++;
16027         if (flags & NDR_SET_VALUES) {
16028                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16029         }
16030         if (flags & NDR_IN) {
16031                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
16032                 ndr->depth++;
16033                 ndr_print_ptr(ndr, "handle", r->in.handle);
16034                 ndr->depth++;
16035                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16036                 ndr->depth--;
16037                 ndr_print_string(ndr, "form_name", r->in.form_name);
16038                 ndr_print_uint32(ndr, "level", r->in.level);
16039                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
16040                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
16041                 ndr->depth--;
16042         }
16043         if (flags & NDR_OUT) {
16044                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
16045                 ndr->depth++;
16046                 ndr_print_WERROR(ndr, "result", r->out.result);
16047                 ndr->depth--;
16048         }
16049         ndr->depth--;
16050 }
16051
16052 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
16053 {
16054         if (flags & NDR_IN) {
16055                 if (r->in.handle == NULL) {
16056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16057                 }
16058                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16061                 if (r->in.buffer) {
16062                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16063                 }
16064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16065         }
16066         if (flags & NDR_OUT) {
16067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16068                 if (r->out.info) {
16069                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16070                 }
16071                 if (r->out.needed == NULL) {
16072                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16073                 }
16074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
16076                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16077         }
16078         return NDR_ERR_SUCCESS;
16079 }
16080
16081 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
16082 {
16083         uint32_t _ptr_buffer;
16084         uint32_t _ptr_info;
16085         TALLOC_CTX *_mem_save_handle_0;
16086         TALLOC_CTX *_mem_save_buffer_0;
16087         TALLOC_CTX *_mem_save_info_0;
16088         TALLOC_CTX *_mem_save_needed_0;
16089         if (flags & NDR_IN) {
16090                 ZERO_STRUCT(r->out);
16091
16092                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16093                         NDR_PULL_ALLOC(ndr, r->in.handle);
16094                 }
16095                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16096                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16097                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16099                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16101                 if (_ptr_buffer) {
16102                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16103                 } else {
16104                         r->in.buffer = NULL;
16105                 }
16106                 if (r->in.buffer) {
16107                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16108                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16109                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16111                 }
16112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16113                 NDR_PULL_ALLOC(ndr, r->out.needed);
16114                 ZERO_STRUCTP(r->out.needed);
16115         }
16116         if (flags & NDR_OUT) {
16117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16118                 if (_ptr_info) {
16119                         NDR_PULL_ALLOC(ndr, r->out.info);
16120                 } else {
16121                         r->out.info = NULL;
16122                 }
16123                 if (r->out.info) {
16124                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16125                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16126                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16128                 }
16129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16130                         NDR_PULL_ALLOC(ndr, r->out.needed);
16131                 }
16132                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16133                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
16137                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16138         }
16139         return NDR_ERR_SUCCESS;
16140 }
16141
16142 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
16143 {
16144         uint32_t cntr_info_0;
16145         if (flags & NDR_IN) {
16146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16148         }
16149         if (flags & NDR_OUT) {
16150                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16151                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16152                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16153                 }
16154                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16155                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16156                 }
16157         }
16158         return NDR_ERR_SUCCESS;
16159 }
16160
16161 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
16162 {
16163         uint32_t cntr_info_0;
16164         TALLOC_CTX *_mem_save_info_0;
16165         if (flags & NDR_IN) {
16166                 ZERO_STRUCT(r->out);
16167
16168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16170         }
16171         if (flags & NDR_OUT) {
16172                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16173                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16174                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16175                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16176                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16177                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16178                 }
16179                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16180                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16181                 }
16182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16183         }
16184         return NDR_ERR_SUCCESS;
16185 }
16186
16187 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
16188 {
16189         uint32_t cntr_info_1;
16190         ndr_print_struct(ndr, name, "spoolss_EnumForms");
16191         ndr->depth++;
16192         if (flags & NDR_SET_VALUES) {
16193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16194         }
16195         if (flags & NDR_IN) {
16196                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
16197                 ndr->depth++;
16198                 ndr_print_ptr(ndr, "handle", r->in.handle);
16199                 ndr->depth++;
16200                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16201                 ndr->depth--;
16202                 ndr_print_uint32(ndr, "level", r->in.level);
16203                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16204                 ndr->depth++;
16205                 if (r->in.buffer) {
16206                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16207                 }
16208                 ndr->depth--;
16209                 ndr_print_uint32(ndr, "offered", r->in.offered);
16210                 ndr->depth--;
16211         }
16212         if (flags & NDR_OUT) {
16213                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
16214                 ndr->depth++;
16215                 ndr_print_ptr(ndr, "info", r->out.info);
16216                 ndr->depth++;
16217                 if (r->out.info) {
16218                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
16219                         ndr->depth++;
16220                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
16221                                 char *idx_1=NULL;
16222                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16223                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16224                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
16225                                         free(idx_1);
16226                                 }
16227                         }
16228                         ndr->depth--;
16229                 }
16230                 ndr->depth--;
16231                 ndr_print_ptr(ndr, "needed", r->out.needed);
16232                 ndr->depth++;
16233                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16234                 ndr->depth--;
16235                 ndr_print_uint32(ndr, "count", r->out.count);
16236                 ndr_print_WERROR(ndr, "result", r->out.result);
16237                 ndr->depth--;
16238         }
16239         ndr->depth--;
16240 }
16241
16242 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
16243 {
16244         if (flags & NDR_IN) {
16245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16246                 if (r->in.servername) {
16247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16251                 }
16252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16254                 if (r->in.buffer) {
16255                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16256                 }
16257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16258         }
16259         if (flags & NDR_OUT) {
16260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16261                 if (r->out.info) {
16262                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16263                 }
16264                 if (r->out.needed == NULL) {
16265                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16266                 }
16267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
16269                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16270         }
16271         return NDR_ERR_SUCCESS;
16272 }
16273
16274 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
16275 {
16276         uint32_t _ptr_servername;
16277         uint32_t _ptr_buffer;
16278         uint32_t _ptr_info;
16279         TALLOC_CTX *_mem_save_servername_0;
16280         TALLOC_CTX *_mem_save_buffer_0;
16281         TALLOC_CTX *_mem_save_info_0;
16282         TALLOC_CTX *_mem_save_needed_0;
16283         if (flags & NDR_IN) {
16284                 ZERO_STRUCT(r->out);
16285
16286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16287                 if (_ptr_servername) {
16288                         NDR_PULL_ALLOC(ndr, r->in.servername);
16289                 } else {
16290                         r->in.servername = NULL;
16291                 }
16292                 if (r->in.servername) {
16293                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16296                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16297                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16298                                 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));
16299                         }
16300                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16303                 }
16304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16306                 if (_ptr_buffer) {
16307                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16308                 } else {
16309                         r->in.buffer = NULL;
16310                 }
16311                 if (r->in.buffer) {
16312                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16313                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16314                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16316                 }
16317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16318                 NDR_PULL_ALLOC(ndr, r->out.needed);
16319                 ZERO_STRUCTP(r->out.needed);
16320         }
16321         if (flags & NDR_OUT) {
16322                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16323                 if (_ptr_info) {
16324                         NDR_PULL_ALLOC(ndr, r->out.info);
16325                 } else {
16326                         r->out.info = NULL;
16327                 }
16328                 if (r->out.info) {
16329                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16330                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16331                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16333                 }
16334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16335                         NDR_PULL_ALLOC(ndr, r->out.needed);
16336                 }
16337                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
16342                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16343         }
16344         return NDR_ERR_SUCCESS;
16345 }
16346
16347 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
16348 {
16349         uint32_t cntr_info_0;
16350         if (flags & NDR_IN) {
16351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16353         }
16354         if (flags & NDR_OUT) {
16355                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16356                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16357                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16358                 }
16359                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16360                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16361                 }
16362         }
16363         return NDR_ERR_SUCCESS;
16364 }
16365
16366 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
16367 {
16368         uint32_t cntr_info_0;
16369         TALLOC_CTX *_mem_save_info_0;
16370         if (flags & NDR_IN) {
16371                 ZERO_STRUCT(r->out);
16372
16373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16375         }
16376         if (flags & NDR_OUT) {
16377                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16378                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16379                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16380                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16381                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16382                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16383                 }
16384                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16385                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16386                 }
16387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16388         }
16389         return NDR_ERR_SUCCESS;
16390 }
16391
16392 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
16393 {
16394         uint32_t cntr_info_1;
16395         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
16396         ndr->depth++;
16397         if (flags & NDR_SET_VALUES) {
16398                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16399         }
16400         if (flags & NDR_IN) {
16401                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
16402                 ndr->depth++;
16403                 ndr_print_ptr(ndr, "servername", r->in.servername);
16404                 ndr->depth++;
16405                 if (r->in.servername) {
16406                         ndr_print_string(ndr, "servername", r->in.servername);
16407                 }
16408                 ndr->depth--;
16409                 ndr_print_uint32(ndr, "level", r->in.level);
16410                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16411                 ndr->depth++;
16412                 if (r->in.buffer) {
16413                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16414                 }
16415                 ndr->depth--;
16416                 ndr_print_uint32(ndr, "offered", r->in.offered);
16417                 ndr->depth--;
16418         }
16419         if (flags & NDR_OUT) {
16420                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
16421                 ndr->depth++;
16422                 ndr_print_ptr(ndr, "info", r->out.info);
16423                 ndr->depth++;
16424                 if (r->out.info) {
16425                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
16426                         ndr->depth++;
16427                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
16428                                 char *idx_1=NULL;
16429                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16430                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16431                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
16432                                         free(idx_1);
16433                                 }
16434                         }
16435                         ndr->depth--;
16436                 }
16437                 ndr->depth--;
16438                 ndr_print_ptr(ndr, "needed", r->out.needed);
16439                 ndr->depth++;
16440                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16441                 ndr->depth--;
16442                 ndr_print_uint32(ndr, "count", r->out.count);
16443                 ndr_print_WERROR(ndr, "result", r->out.result);
16444                 ndr->depth--;
16445         }
16446         ndr->depth--;
16447 }
16448
16449 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
16450 {
16451         if (flags & NDR_IN) {
16452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16453                 if (r->in.servername) {
16454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16457                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16458                 }
16459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16461                 if (r->in.buffer) {
16462                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16463                 }
16464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16465         }
16466         if (flags & NDR_OUT) {
16467                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16468                 if (r->out.info) {
16469                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16470                 }
16471                 if (r->out.needed == NULL) {
16472                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16473                 }
16474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
16476                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16477         }
16478         return NDR_ERR_SUCCESS;
16479 }
16480
16481 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
16482 {
16483         uint32_t _ptr_servername;
16484         uint32_t _ptr_buffer;
16485         uint32_t _ptr_info;
16486         TALLOC_CTX *_mem_save_servername_0;
16487         TALLOC_CTX *_mem_save_buffer_0;
16488         TALLOC_CTX *_mem_save_info_0;
16489         TALLOC_CTX *_mem_save_needed_0;
16490         if (flags & NDR_IN) {
16491                 ZERO_STRUCT(r->out);
16492
16493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16494                 if (_ptr_servername) {
16495                         NDR_PULL_ALLOC(ndr, r->in.servername);
16496                 } else {
16497                         r->in.servername = NULL;
16498                 }
16499                 if (r->in.servername) {
16500                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16501                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16503                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16504                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16505                                 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));
16506                         }
16507                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16508                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16509                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16510                 }
16511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16512                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16513                 if (_ptr_buffer) {
16514                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16515                 } else {
16516                         r->in.buffer = NULL;
16517                 }
16518                 if (r->in.buffer) {
16519                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16520                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16521                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16523                 }
16524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16525                 NDR_PULL_ALLOC(ndr, r->out.needed);
16526                 ZERO_STRUCTP(r->out.needed);
16527         }
16528         if (flags & NDR_OUT) {
16529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16530                 if (_ptr_info) {
16531                         NDR_PULL_ALLOC(ndr, r->out.info);
16532                 } else {
16533                         r->out.info = NULL;
16534                 }
16535                 if (r->out.info) {
16536                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16537                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16538                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16539                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16540                 }
16541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16542                         NDR_PULL_ALLOC(ndr, r->out.needed);
16543                 }
16544                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16545                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
16549                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16550         }
16551         return NDR_ERR_SUCCESS;
16552 }
16553
16554 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
16555 {
16556         uint32_t cntr_info_0;
16557         if (flags & NDR_IN) {
16558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16560         }
16561         if (flags & NDR_OUT) {
16562                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16563                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16564                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16565                 }
16566                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16567                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16568                 }
16569         }
16570         return NDR_ERR_SUCCESS;
16571 }
16572
16573 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
16574 {
16575         uint32_t cntr_info_0;
16576         TALLOC_CTX *_mem_save_info_0;
16577         if (flags & NDR_IN) {
16578                 ZERO_STRUCT(r->out);
16579
16580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16582         }
16583         if (flags & NDR_OUT) {
16584                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16585                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16586                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16587                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16588                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16589                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16590                 }
16591                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16592                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16593                 }
16594                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16595         }
16596         return NDR_ERR_SUCCESS;
16597 }
16598
16599 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
16600 {
16601         uint32_t cntr_info_1;
16602         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
16603         ndr->depth++;
16604         if (flags & NDR_SET_VALUES) {
16605                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16606         }
16607         if (flags & NDR_IN) {
16608                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
16609                 ndr->depth++;
16610                 ndr_print_ptr(ndr, "servername", r->in.servername);
16611                 ndr->depth++;
16612                 if (r->in.servername) {
16613                         ndr_print_string(ndr, "servername", r->in.servername);
16614                 }
16615                 ndr->depth--;
16616                 ndr_print_uint32(ndr, "level", r->in.level);
16617                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16618                 ndr->depth++;
16619                 if (r->in.buffer) {
16620                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16621                 }
16622                 ndr->depth--;
16623                 ndr_print_uint32(ndr, "offered", r->in.offered);
16624                 ndr->depth--;
16625         }
16626         if (flags & NDR_OUT) {
16627                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
16628                 ndr->depth++;
16629                 ndr_print_ptr(ndr, "info", r->out.info);
16630                 ndr->depth++;
16631                 if (r->out.info) {
16632                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
16633                         ndr->depth++;
16634                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
16635                                 char *idx_1=NULL;
16636                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16637                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16638                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
16639                                         free(idx_1);
16640                                 }
16641                         }
16642                         ndr->depth--;
16643                 }
16644                 ndr->depth--;
16645                 ndr_print_ptr(ndr, "needed", r->out.needed);
16646                 ndr->depth++;
16647                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16648                 ndr->depth--;
16649                 ndr_print_uint32(ndr, "count", r->out.count);
16650                 ndr_print_WERROR(ndr, "result", r->out.result);
16651                 ndr->depth--;
16652         }
16653         ndr->depth--;
16654 }
16655
16656 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
16657 {
16658         if (flags & NDR_IN) {
16659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
16660                 if (r->in.server_name) {
16661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
16662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
16664                         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));
16665                 }
16666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
16667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
16668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
16670                 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));
16671         }
16672         if (flags & NDR_OUT) {
16673                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16674         }
16675         return NDR_ERR_SUCCESS;
16676 }
16677
16678 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
16679 {
16680         uint32_t _ptr_server_name;
16681         TALLOC_CTX *_mem_save_server_name_0;
16682         if (flags & NDR_IN) {
16683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
16684                 if (_ptr_server_name) {
16685                         NDR_PULL_ALLOC(ndr, r->in.server_name);
16686                 } else {
16687                         r->in.server_name = NULL;
16688                 }
16689                 if (r->in.server_name) {
16690                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16691                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
16692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
16693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
16694                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
16695                                 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));
16696                         }
16697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
16698                         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));
16699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
16700                 }
16701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
16702                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
16703                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
16704                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
16705                         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));
16706                 }
16707                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
16708                 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));
16709         }
16710         if (flags & NDR_OUT) {
16711                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16712         }
16713         return NDR_ERR_SUCCESS;
16714 }
16715
16716 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
16717 {
16718         ndr_print_struct(ndr, name, "spoolss_AddPort");
16719         ndr->depth++;
16720         if (flags & NDR_SET_VALUES) {
16721                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16722         }
16723         if (flags & NDR_IN) {
16724                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
16725                 ndr->depth++;
16726                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
16727                 ndr->depth++;
16728                 if (r->in.server_name) {
16729                         ndr_print_string(ndr, "server_name", r->in.server_name);
16730                 }
16731                 ndr->depth--;
16732                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
16733                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
16734                 ndr->depth--;
16735         }
16736         if (flags & NDR_OUT) {
16737                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
16738                 ndr->depth++;
16739                 ndr_print_WERROR(ndr, "result", r->out.result);
16740                 ndr->depth--;
16741         }
16742         ndr->depth--;
16743 }
16744
16745 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
16746 {
16747         if (flags & NDR_IN) {
16748         }
16749         if (flags & NDR_OUT) {
16750                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16751         }
16752         return NDR_ERR_SUCCESS;
16753 }
16754
16755 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
16756 {
16757         if (flags & NDR_IN) {
16758         }
16759         if (flags & NDR_OUT) {
16760                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16761         }
16762         return NDR_ERR_SUCCESS;
16763 }
16764
16765 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
16766 {
16767         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
16768         ndr->depth++;
16769         if (flags & NDR_SET_VALUES) {
16770                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16771         }
16772         if (flags & NDR_IN) {
16773                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
16774                 ndr->depth++;
16775                 ndr->depth--;
16776         }
16777         if (flags & NDR_OUT) {
16778                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
16779                 ndr->depth++;
16780                 ndr_print_WERROR(ndr, "result", r->out.result);
16781                 ndr->depth--;
16782         }
16783         ndr->depth--;
16784 }
16785
16786 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
16787 {
16788         if (flags & NDR_IN) {
16789         }
16790         if (flags & NDR_OUT) {
16791                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16792         }
16793         return NDR_ERR_SUCCESS;
16794 }
16795
16796 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
16797 {
16798         if (flags & NDR_IN) {
16799         }
16800         if (flags & NDR_OUT) {
16801                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16802         }
16803         return NDR_ERR_SUCCESS;
16804 }
16805
16806 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
16807 {
16808         ndr_print_struct(ndr, name, "spoolss_DeletePort");
16809         ndr->depth++;
16810         if (flags & NDR_SET_VALUES) {
16811                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16812         }
16813         if (flags & NDR_IN) {
16814                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
16815                 ndr->depth++;
16816                 ndr->depth--;
16817         }
16818         if (flags & NDR_OUT) {
16819                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
16820                 ndr->depth++;
16821                 ndr_print_WERROR(ndr, "result", r->out.result);
16822                 ndr->depth--;
16823         }
16824         ndr->depth--;
16825 }
16826
16827 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
16828 {
16829         if (flags & NDR_IN) {
16830         }
16831         if (flags & NDR_OUT) {
16832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16833         }
16834         return NDR_ERR_SUCCESS;
16835 }
16836
16837 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
16838 {
16839         if (flags & NDR_IN) {
16840         }
16841         if (flags & NDR_OUT) {
16842                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16843         }
16844         return NDR_ERR_SUCCESS;
16845 }
16846
16847 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
16848 {
16849         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
16850         ndr->depth++;
16851         if (flags & NDR_SET_VALUES) {
16852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16853         }
16854         if (flags & NDR_IN) {
16855                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
16856                 ndr->depth++;
16857                 ndr->depth--;
16858         }
16859         if (flags & NDR_OUT) {
16860                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
16861                 ndr->depth++;
16862                 ndr_print_WERROR(ndr, "result", r->out.result);
16863                 ndr->depth--;
16864         }
16865         ndr->depth--;
16866 }
16867
16868 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
16869 {
16870         if (flags & NDR_IN) {
16871         }
16872         if (flags & NDR_OUT) {
16873                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16874         }
16875         return NDR_ERR_SUCCESS;
16876 }
16877
16878 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
16879 {
16880         if (flags & NDR_IN) {
16881         }
16882         if (flags & NDR_OUT) {
16883                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16884         }
16885         return NDR_ERR_SUCCESS;
16886 }
16887
16888 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
16889 {
16890         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
16891         ndr->depth++;
16892         if (flags & NDR_SET_VALUES) {
16893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16894         }
16895         if (flags & NDR_IN) {
16896                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
16897                 ndr->depth++;
16898                 ndr->depth--;
16899         }
16900         if (flags & NDR_OUT) {
16901                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
16902                 ndr->depth++;
16903                 ndr_print_WERROR(ndr, "result", r->out.result);
16904                 ndr->depth--;
16905         }
16906         ndr->depth--;
16907 }
16908
16909 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
16910 {
16911         if (flags & NDR_IN) {
16912         }
16913         if (flags & NDR_OUT) {
16914                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16915         }
16916         return NDR_ERR_SUCCESS;
16917 }
16918
16919 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
16920 {
16921         if (flags & NDR_IN) {
16922         }
16923         if (flags & NDR_OUT) {
16924                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16925         }
16926         return NDR_ERR_SUCCESS;
16927 }
16928
16929 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
16930 {
16931         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
16932         ndr->depth++;
16933         if (flags & NDR_SET_VALUES) {
16934                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16935         }
16936         if (flags & NDR_IN) {
16937                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
16938                 ndr->depth++;
16939                 ndr->depth--;
16940         }
16941         if (flags & NDR_OUT) {
16942                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
16943                 ndr->depth++;
16944                 ndr_print_WERROR(ndr, "result", r->out.result);
16945                 ndr->depth--;
16946         }
16947         ndr->depth--;
16948 }
16949
16950 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
16951 {
16952         if (flags & NDR_IN) {
16953         }
16954         if (flags & NDR_OUT) {
16955                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16956         }
16957         return NDR_ERR_SUCCESS;
16958 }
16959
16960 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
16961 {
16962         if (flags & NDR_IN) {
16963         }
16964         if (flags & NDR_OUT) {
16965                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16966         }
16967         return NDR_ERR_SUCCESS;
16968 }
16969
16970 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
16971 {
16972         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
16973         ndr->depth++;
16974         if (flags & NDR_SET_VALUES) {
16975                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16976         }
16977         if (flags & NDR_IN) {
16978                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
16979                 ndr->depth++;
16980                 ndr->depth--;
16981         }
16982         if (flags & NDR_OUT) {
16983                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
16984                 ndr->depth++;
16985                 ndr_print_WERROR(ndr, "result", r->out.result);
16986                 ndr->depth--;
16987         }
16988         ndr->depth--;
16989 }
16990
16991 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
16992 {
16993         if (flags & NDR_IN) {
16994         }
16995         if (flags & NDR_OUT) {
16996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16997         }
16998         return NDR_ERR_SUCCESS;
16999 }
17000
17001 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
17002 {
17003         if (flags & NDR_IN) {
17004         }
17005         if (flags & NDR_OUT) {
17006                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17007         }
17008         return NDR_ERR_SUCCESS;
17009 }
17010
17011 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
17012 {
17013         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
17014         ndr->depth++;
17015         if (flags & NDR_SET_VALUES) {
17016                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17017         }
17018         if (flags & NDR_IN) {
17019                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
17020                 ndr->depth++;
17021                 ndr->depth--;
17022         }
17023         if (flags & NDR_OUT) {
17024                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
17025                 ndr->depth++;
17026                 ndr_print_WERROR(ndr, "result", r->out.result);
17027                 ndr->depth--;
17028         }
17029         ndr->depth--;
17030 }
17031
17032 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
17033 {
17034         if (flags & NDR_IN) {
17035         }
17036         if (flags & NDR_OUT) {
17037                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17038         }
17039         return NDR_ERR_SUCCESS;
17040 }
17041
17042 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
17043 {
17044         if (flags & NDR_IN) {
17045         }
17046         if (flags & NDR_OUT) {
17047                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17048         }
17049         return NDR_ERR_SUCCESS;
17050 }
17051
17052 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
17053 {
17054         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
17055         ndr->depth++;
17056         if (flags & NDR_SET_VALUES) {
17057                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17058         }
17059         if (flags & NDR_IN) {
17060                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
17061                 ndr->depth++;
17062                 ndr->depth--;
17063         }
17064         if (flags & NDR_OUT) {
17065                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
17066                 ndr->depth++;
17067                 ndr_print_WERROR(ndr, "result", r->out.result);
17068                 ndr->depth--;
17069         }
17070         ndr->depth--;
17071 }
17072
17073 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
17074 {
17075         if (flags & NDR_IN) {
17076         }
17077         if (flags & NDR_OUT) {
17078                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17079         }
17080         return NDR_ERR_SUCCESS;
17081 }
17082
17083 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
17084 {
17085         if (flags & NDR_IN) {
17086         }
17087         if (flags & NDR_OUT) {
17088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17089         }
17090         return NDR_ERR_SUCCESS;
17091 }
17092
17093 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
17094 {
17095         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
17096         ndr->depth++;
17097         if (flags & NDR_SET_VALUES) {
17098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17099         }
17100         if (flags & NDR_IN) {
17101                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
17102                 ndr->depth++;
17103                 ndr->depth--;
17104         }
17105         if (flags & NDR_OUT) {
17106                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
17107                 ndr->depth++;
17108                 ndr_print_WERROR(ndr, "result", r->out.result);
17109                 ndr->depth--;
17110         }
17111         ndr->depth--;
17112 }
17113
17114 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
17115 {
17116         if (flags & NDR_IN) {
17117         }
17118         if (flags & NDR_OUT) {
17119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17120         }
17121         return NDR_ERR_SUCCESS;
17122 }
17123
17124 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
17125 {
17126         if (flags & NDR_IN) {
17127         }
17128         if (flags & NDR_OUT) {
17129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17130         }
17131         return NDR_ERR_SUCCESS;
17132 }
17133
17134 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
17135 {
17136         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
17137         ndr->depth++;
17138         if (flags & NDR_SET_VALUES) {
17139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17140         }
17141         if (flags & NDR_IN) {
17142                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
17143                 ndr->depth++;
17144                 ndr->depth--;
17145         }
17146         if (flags & NDR_OUT) {
17147                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
17148                 ndr->depth++;
17149                 ndr_print_WERROR(ndr, "result", r->out.result);
17150                 ndr->depth--;
17151         }
17152         ndr->depth--;
17153 }
17154
17155 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
17156 {
17157         if (flags & NDR_IN) {
17158         }
17159         if (flags & NDR_OUT) {
17160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17161         }
17162         return NDR_ERR_SUCCESS;
17163 }
17164
17165 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
17166 {
17167         if (flags & NDR_IN) {
17168         }
17169         if (flags & NDR_OUT) {
17170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17171         }
17172         return NDR_ERR_SUCCESS;
17173 }
17174
17175 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
17176 {
17177         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
17178         ndr->depth++;
17179         if (flags & NDR_SET_VALUES) {
17180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17181         }
17182         if (flags & NDR_IN) {
17183                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
17184                 ndr->depth++;
17185                 ndr->depth--;
17186         }
17187         if (flags & NDR_OUT) {
17188                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
17189                 ndr->depth++;
17190                 ndr_print_WERROR(ndr, "result", r->out.result);
17191                 ndr->depth--;
17192         }
17193         ndr->depth--;
17194 }
17195
17196 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
17197 {
17198         if (flags & NDR_IN) {
17199         }
17200         if (flags & NDR_OUT) {
17201                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17202         }
17203         return NDR_ERR_SUCCESS;
17204 }
17205
17206 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
17207 {
17208         if (flags & NDR_IN) {
17209         }
17210         if (flags & NDR_OUT) {
17211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17212         }
17213         return NDR_ERR_SUCCESS;
17214 }
17215
17216 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
17217 {
17218         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
17219         ndr->depth++;
17220         if (flags & NDR_SET_VALUES) {
17221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17222         }
17223         if (flags & NDR_IN) {
17224                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
17225                 ndr->depth++;
17226                 ndr->depth--;
17227         }
17228         if (flags & NDR_OUT) {
17229                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
17230                 ndr->depth++;
17231                 ndr_print_WERROR(ndr, "result", r->out.result);
17232                 ndr->depth--;
17233         }
17234         ndr->depth--;
17235 }
17236
17237 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
17238 {
17239         if (flags & NDR_IN) {
17240         }
17241         if (flags & NDR_OUT) {
17242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17243         }
17244         return NDR_ERR_SUCCESS;
17245 }
17246
17247 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
17248 {
17249         if (flags & NDR_IN) {
17250         }
17251         if (flags & NDR_OUT) {
17252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17253         }
17254         return NDR_ERR_SUCCESS;
17255 }
17256
17257 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
17258 {
17259         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
17260         ndr->depth++;
17261         if (flags & NDR_SET_VALUES) {
17262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17263         }
17264         if (flags & NDR_IN) {
17265                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
17266                 ndr->depth++;
17267                 ndr->depth--;
17268         }
17269         if (flags & NDR_OUT) {
17270                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
17271                 ndr->depth++;
17272                 ndr_print_WERROR(ndr, "result", r->out.result);
17273                 ndr->depth--;
17274         }
17275         ndr->depth--;
17276 }
17277
17278 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
17279 {
17280         if (flags & NDR_IN) {
17281         }
17282         if (flags & NDR_OUT) {
17283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17284         }
17285         return NDR_ERR_SUCCESS;
17286 }
17287
17288 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
17289 {
17290         if (flags & NDR_IN) {
17291         }
17292         if (flags & NDR_OUT) {
17293                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17294         }
17295         return NDR_ERR_SUCCESS;
17296 }
17297
17298 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
17299 {
17300         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
17301         ndr->depth++;
17302         if (flags & NDR_SET_VALUES) {
17303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17304         }
17305         if (flags & NDR_IN) {
17306                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
17307                 ndr->depth++;
17308                 ndr->depth--;
17309         }
17310         if (flags & NDR_OUT) {
17311                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
17312                 ndr->depth++;
17313                 ndr_print_WERROR(ndr, "result", r->out.result);
17314                 ndr->depth--;
17315         }
17316         ndr->depth--;
17317 }
17318
17319 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
17320 {
17321         if (flags & NDR_IN) {
17322                 if (r->in.handle == NULL) {
17323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17324                 }
17325                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
17327                 if (r->in.data_type) {
17328                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
17329                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
17331                         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));
17332                 }
17333                 if (r->in.devmode_ctr == NULL) {
17334                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17335                 }
17336                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
17337         }
17338         if (flags & NDR_OUT) {
17339                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17340         }
17341         return NDR_ERR_SUCCESS;
17342 }
17343
17344 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
17345 {
17346         uint32_t _ptr_data_type;
17347         TALLOC_CTX *_mem_save_handle_0;
17348         TALLOC_CTX *_mem_save_data_type_0;
17349         TALLOC_CTX *_mem_save_devmode_ctr_0;
17350         if (flags & NDR_IN) {
17351                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17352                         NDR_PULL_ALLOC(ndr, r->in.handle);
17353                 }
17354                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17355                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17356                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17357                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17358                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
17359                 if (_ptr_data_type) {
17360                         NDR_PULL_ALLOC(ndr, r->in.data_type);
17361                 } else {
17362                         r->in.data_type = NULL;
17363                 }
17364                 if (r->in.data_type) {
17365                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
17366                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
17367                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
17368                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
17369                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
17370                                 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));
17371                         }
17372                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
17373                         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));
17374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
17375                 }
17376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17377                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
17378                 }
17379                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17380                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
17381                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
17382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17383         }
17384         if (flags & NDR_OUT) {
17385                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17386         }
17387         return NDR_ERR_SUCCESS;
17388 }
17389
17390 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
17391 {
17392         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
17393         ndr->depth++;
17394         if (flags & NDR_SET_VALUES) {
17395                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17396         }
17397         if (flags & NDR_IN) {
17398                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
17399                 ndr->depth++;
17400                 ndr_print_ptr(ndr, "handle", r->in.handle);
17401                 ndr->depth++;
17402                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17403                 ndr->depth--;
17404                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
17405                 ndr->depth++;
17406                 if (r->in.data_type) {
17407                         ndr_print_string(ndr, "data_type", r->in.data_type);
17408                 }
17409                 ndr->depth--;
17410                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
17411                 ndr->depth++;
17412                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
17413                 ndr->depth--;
17414                 ndr->depth--;
17415         }
17416         if (flags & NDR_OUT) {
17417                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
17418                 ndr->depth++;
17419                 ndr_print_WERROR(ndr, "result", r->out.result);
17420                 ndr->depth--;
17421         }
17422         ndr->depth--;
17423 }
17424
17425 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
17426 {
17427         if (flags & NDR_IN) {
17428                 if (r->in.handle == NULL) {
17429                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17430                 }
17431                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
17433                 if (r->in.architecture) {
17434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
17435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
17437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17438                 }
17439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17441                 if (r->in.buffer) {
17442                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17443                 }
17444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
17446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
17447         }
17448         if (flags & NDR_OUT) {
17449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17450                 if (r->out.info) {
17451                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
17452                 }
17453                 if (r->out.needed == NULL) {
17454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17455                 }
17456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17457                 if (r->out.server_major_version == NULL) {
17458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17459                 }
17460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
17461                 if (r->out.server_minor_version == NULL) {
17462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17463                 }
17464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
17465                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17466         }
17467         return NDR_ERR_SUCCESS;
17468 }
17469
17470 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
17471 {
17472         uint32_t _ptr_architecture;
17473         uint32_t _ptr_buffer;
17474         uint32_t _ptr_info;
17475         TALLOC_CTX *_mem_save_handle_0;
17476         TALLOC_CTX *_mem_save_architecture_0;
17477         TALLOC_CTX *_mem_save_buffer_0;
17478         TALLOC_CTX *_mem_save_info_0;
17479         TALLOC_CTX *_mem_save_needed_0;
17480         TALLOC_CTX *_mem_save_server_major_version_0;
17481         TALLOC_CTX *_mem_save_server_minor_version_0;
17482         if (flags & NDR_IN) {
17483                 ZERO_STRUCT(r->out);
17484
17485                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17486                         NDR_PULL_ALLOC(ndr, r->in.handle);
17487                 }
17488                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17489                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17490                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17491                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
17493                 if (_ptr_architecture) {
17494                         NDR_PULL_ALLOC(ndr, r->in.architecture);
17495                 } else {
17496                         r->in.architecture = NULL;
17497                 }
17498                 if (r->in.architecture) {
17499                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
17500                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
17501                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
17502                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
17503                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
17504                                 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));
17505                         }
17506                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
17507                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
17508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
17509                 }
17510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17511                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17512                 if (_ptr_buffer) {
17513                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17514                 } else {
17515                         r->in.buffer = NULL;
17516                 }
17517                 if (r->in.buffer) {
17518                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17519                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17520                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17522                 }
17523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
17525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
17526                 NDR_PULL_ALLOC(ndr, r->out.needed);
17527                 ZERO_STRUCTP(r->out.needed);
17528                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
17529                 ZERO_STRUCTP(r->out.server_major_version);
17530                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
17531                 ZERO_STRUCTP(r->out.server_minor_version);
17532         }
17533         if (flags & NDR_OUT) {
17534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17535                 if (_ptr_info) {
17536                         NDR_PULL_ALLOC(ndr, r->out.info);
17537                 } else {
17538                         r->out.info = NULL;
17539                 }
17540                 if (r->out.info) {
17541                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17542                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17543                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
17544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17545                 }
17546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17547                         NDR_PULL_ALLOC(ndr, r->out.needed);
17548                 }
17549                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17550                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17554                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
17555                 }
17556                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
17557                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
17558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
17559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
17560                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17561                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
17562                 }
17563                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
17564                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
17565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
17566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
17567                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17568         }
17569         return NDR_ERR_SUCCESS;
17570 }
17571
17572 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
17573 {
17574         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
17575         ndr->depth++;
17576         if (flags & NDR_SET_VALUES) {
17577                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17578         }
17579         if (flags & NDR_IN) {
17580                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
17581                 ndr->depth++;
17582                 ndr_print_ptr(ndr, "handle", r->in.handle);
17583                 ndr->depth++;
17584                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17585                 ndr->depth--;
17586                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
17587                 ndr->depth++;
17588                 if (r->in.architecture) {
17589                         ndr_print_string(ndr, "architecture", r->in.architecture);
17590                 }
17591                 ndr->depth--;
17592                 ndr_print_uint32(ndr, "level", r->in.level);
17593                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17594                 ndr->depth++;
17595                 if (r->in.buffer) {
17596                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17597                 }
17598                 ndr->depth--;
17599                 ndr_print_uint32(ndr, "offered", r->in.offered);
17600                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
17601                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
17602                 ndr->depth--;
17603         }
17604         if (flags & NDR_OUT) {
17605                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
17606                 ndr->depth++;
17607                 ndr_print_ptr(ndr, "info", r->out.info);
17608                 ndr->depth++;
17609                 if (r->out.info) {
17610                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
17611                 }
17612                 ndr->depth--;
17613                 ndr_print_ptr(ndr, "needed", r->out.needed);
17614                 ndr->depth++;
17615                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17616                 ndr->depth--;
17617                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
17618                 ndr->depth++;
17619                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
17620                 ndr->depth--;
17621                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
17622                 ndr->depth++;
17623                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
17624                 ndr->depth--;
17625                 ndr_print_WERROR(ndr, "result", r->out.result);
17626                 ndr->depth--;
17627         }
17628         ndr->depth--;
17629 }
17630
17631 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
17632 {
17633         if (flags & NDR_IN) {
17634         }
17635         if (flags & NDR_OUT) {
17636                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17637         }
17638         return NDR_ERR_SUCCESS;
17639 }
17640
17641 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
17642 {
17643         if (flags & NDR_IN) {
17644         }
17645         if (flags & NDR_OUT) {
17646                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17647         }
17648         return NDR_ERR_SUCCESS;
17649 }
17650
17651 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
17652 {
17653         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
17654         ndr->depth++;
17655         if (flags & NDR_SET_VALUES) {
17656                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17657         }
17658         if (flags & NDR_IN) {
17659                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
17660                 ndr->depth++;
17661                 ndr->depth--;
17662         }
17663         if (flags & NDR_OUT) {
17664                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
17665                 ndr->depth++;
17666                 ndr_print_WERROR(ndr, "result", r->out.result);
17667                 ndr->depth--;
17668         }
17669         ndr->depth--;
17670 }
17671
17672 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
17673 {
17674         if (flags & NDR_IN) {
17675         }
17676         if (flags & NDR_OUT) {
17677                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17678         }
17679         return NDR_ERR_SUCCESS;
17680 }
17681
17682 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
17683 {
17684         if (flags & NDR_IN) {
17685         }
17686         if (flags & NDR_OUT) {
17687                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17688         }
17689         return NDR_ERR_SUCCESS;
17690 }
17691
17692 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
17693 {
17694         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
17695         ndr->depth++;
17696         if (flags & NDR_SET_VALUES) {
17697                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17698         }
17699         if (flags & NDR_IN) {
17700                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
17701                 ndr->depth++;
17702                 ndr->depth--;
17703         }
17704         if (flags & NDR_OUT) {
17705                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
17706                 ndr->depth++;
17707                 ndr_print_WERROR(ndr, "result", r->out.result);
17708                 ndr->depth--;
17709         }
17710         ndr->depth--;
17711 }
17712
17713 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
17714 {
17715         if (flags & NDR_IN) {
17716                 if (r->in.handle == NULL) {
17717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17718                 }
17719                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17720         }
17721         if (flags & NDR_OUT) {
17722                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17723         }
17724         return NDR_ERR_SUCCESS;
17725 }
17726
17727 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
17728 {
17729         TALLOC_CTX *_mem_save_handle_0;
17730         if (flags & NDR_IN) {
17731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17732                         NDR_PULL_ALLOC(ndr, r->in.handle);
17733                 }
17734                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17735                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17738         }
17739         if (flags & NDR_OUT) {
17740                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17741         }
17742         return NDR_ERR_SUCCESS;
17743 }
17744
17745 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
17746 {
17747         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
17748         ndr->depth++;
17749         if (flags & NDR_SET_VALUES) {
17750                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17751         }
17752         if (flags & NDR_IN) {
17753                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
17754                 ndr->depth++;
17755                 ndr_print_ptr(ndr, "handle", r->in.handle);
17756                 ndr->depth++;
17757                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17758                 ndr->depth--;
17759                 ndr->depth--;
17760         }
17761         if (flags & NDR_OUT) {
17762                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
17763                 ndr->depth++;
17764                 ndr_print_WERROR(ndr, "result", r->out.result);
17765                 ndr->depth--;
17766         }
17767         ndr->depth--;
17768 }
17769
17770 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
17771 {
17772         if (flags & NDR_IN) {
17773         }
17774         if (flags & NDR_OUT) {
17775                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17776         }
17777         return NDR_ERR_SUCCESS;
17778 }
17779
17780 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
17781 {
17782         if (flags & NDR_IN) {
17783         }
17784         if (flags & NDR_OUT) {
17785                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17786         }
17787         return NDR_ERR_SUCCESS;
17788 }
17789
17790 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
17791 {
17792         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
17793         ndr->depth++;
17794         if (flags & NDR_SET_VALUES) {
17795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17796         }
17797         if (flags & NDR_IN) {
17798                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
17799                 ndr->depth++;
17800                 ndr->depth--;
17801         }
17802         if (flags & NDR_OUT) {
17803                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
17804                 ndr->depth++;
17805                 ndr_print_WERROR(ndr, "result", r->out.result);
17806                 ndr->depth--;
17807         }
17808         ndr->depth--;
17809 }
17810
17811 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
17812 {
17813         if (flags & NDR_IN) {
17814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
17815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
17817                 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));
17818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
17819                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
17820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
17821                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17822                 if (r->in.buffer) {
17823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
17824                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
17825                 }
17826         }
17827         if (flags & NDR_OUT) {
17828                 if (r->out.handle == NULL) {
17829                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17830                 }
17831                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17833         }
17834         return NDR_ERR_SUCCESS;
17835 }
17836
17837 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
17838 {
17839         uint32_t _ptr_buffer;
17840         TALLOC_CTX *_mem_save_buffer_0;
17841         TALLOC_CTX *_mem_save_handle_0;
17842         if (flags & NDR_IN) {
17843                 ZERO_STRUCT(r->out);
17844
17845                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
17846                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
17847                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
17848                         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));
17849                 }
17850                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
17851                 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));
17852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
17853                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
17854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
17855                 if (r->in.bufsize > 512) {
17856                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
17857                 }
17858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17859                 if (_ptr_buffer) {
17860                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17861                 } else {
17862                         r->in.buffer = NULL;
17863                 }
17864                 if (r->in.buffer) {
17865                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17866                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
17868                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
17869                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
17870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17871                 }
17872                 NDR_PULL_ALLOC(ndr, r->out.handle);
17873                 ZERO_STRUCTP(r->out.handle);
17874                 if (r->in.buffer) {
17875                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
17876                 }
17877         }
17878         if (flags & NDR_OUT) {
17879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17880                         NDR_PULL_ALLOC(ndr, r->out.handle);
17881                 }
17882                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17883                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
17884                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17887         }
17888         return NDR_ERR_SUCCESS;
17889 }
17890
17891 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
17892 {
17893         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
17894         ndr->depth++;
17895         if (flags & NDR_SET_VALUES) {
17896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17897         }
17898         if (flags & NDR_IN) {
17899                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
17900                 ndr->depth++;
17901                 ndr_print_string(ndr, "server_name", r->in.server_name);
17902                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
17903                 ndr_print_winreg_Type(ndr, "type", r->in.type);
17904                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
17905                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17906                 ndr->depth++;
17907                 if (r->in.buffer) {
17908                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
17909                 }
17910                 ndr->depth--;
17911                 ndr->depth--;
17912         }
17913         if (flags & NDR_OUT) {
17914                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
17915                 ndr->depth++;
17916                 ndr_print_ptr(ndr, "handle", r->out.handle);
17917                 ndr->depth++;
17918                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
17919                 ndr->depth--;
17920                 ndr_print_WERROR(ndr, "result", r->out.result);
17921                 ndr->depth--;
17922         }
17923         ndr->depth--;
17924 }
17925
17926 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
17927 {
17928         if (flags & NDR_IN) {
17929                 if (r->in.handle == NULL) {
17930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17931                 }
17932                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17933                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
17934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
17935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17936                 if (r->in.buffer) {
17937                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
17938                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
17939                 }
17940         }
17941         if (flags & NDR_OUT) {
17942                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17943         }
17944         return NDR_ERR_SUCCESS;
17945 }
17946
17947 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
17948 {
17949         uint32_t _ptr_buffer;
17950         TALLOC_CTX *_mem_save_handle_0;
17951         TALLOC_CTX *_mem_save_buffer_0;
17952         if (flags & NDR_IN) {
17953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17954                         NDR_PULL_ALLOC(ndr, r->in.handle);
17955                 }
17956                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17957                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17958                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17960                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
17961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
17962                 if (r->in.bufsize > 512) {
17963                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
17964                 }
17965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17966                 if (_ptr_buffer) {
17967                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17968                 } else {
17969                         r->in.buffer = NULL;
17970                 }
17971                 if (r->in.buffer) {
17972                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17973                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17974                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
17975                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
17976                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
17977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17978                 }
17979                 if (r->in.buffer) {
17980                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
17981                 }
17982         }
17983         if (flags & NDR_OUT) {
17984                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17985         }
17986         return NDR_ERR_SUCCESS;
17987 }
17988
17989 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
17990 {
17991         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
17992         ndr->depth++;
17993         if (flags & NDR_SET_VALUES) {
17994                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17995         }
17996         if (flags & NDR_IN) {
17997                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
17998                 ndr->depth++;
17999                 ndr_print_ptr(ndr, "handle", r->in.handle);
18000                 ndr->depth++;
18001                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18002                 ndr->depth--;
18003                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
18004                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
18005                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18006                 ndr->depth++;
18007                 if (r->in.buffer) {
18008                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
18009                 }
18010                 ndr->depth--;
18011                 ndr->depth--;
18012         }
18013         if (flags & NDR_OUT) {
18014                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
18015                 ndr->depth++;
18016                 ndr_print_WERROR(ndr, "result", r->out.result);
18017                 ndr->depth--;
18018         }
18019         ndr->depth--;
18020 }
18021
18022 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
18023 {
18024         if (flags & NDR_IN) {
18025                 if (r->in.handle == NULL) {
18026                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18027                 }
18028                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18029         }
18030         if (flags & NDR_OUT) {
18031                 if (r->out.handle == NULL) {
18032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18033                 }
18034                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18035                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18036         }
18037         return NDR_ERR_SUCCESS;
18038 }
18039
18040 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
18041 {
18042         TALLOC_CTX *_mem_save_handle_0;
18043         if (flags & NDR_IN) {
18044                 ZERO_STRUCT(r->out);
18045
18046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18047                         NDR_PULL_ALLOC(ndr, r->in.handle);
18048                 }
18049                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18050                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18051                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18053                 NDR_PULL_ALLOC(ndr, r->out.handle);
18054                 *r->out.handle = *r->in.handle;
18055         }
18056         if (flags & NDR_OUT) {
18057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18058                         NDR_PULL_ALLOC(ndr, r->out.handle);
18059                 }
18060                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18062                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18064                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18065         }
18066         return NDR_ERR_SUCCESS;
18067 }
18068
18069 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
18070 {
18071         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
18072         ndr->depth++;
18073         if (flags & NDR_SET_VALUES) {
18074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18075         }
18076         if (flags & NDR_IN) {
18077                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
18078                 ndr->depth++;
18079                 ndr_print_ptr(ndr, "handle", r->in.handle);
18080                 ndr->depth++;
18081                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18082                 ndr->depth--;
18083                 ndr->depth--;
18084         }
18085         if (flags & NDR_OUT) {
18086                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
18087                 ndr->depth++;
18088                 ndr_print_ptr(ndr, "handle", r->out.handle);
18089                 ndr->depth++;
18090                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18091                 ndr->depth--;
18092                 ndr_print_WERROR(ndr, "result", r->out.result);
18093                 ndr->depth--;
18094         }
18095         ndr->depth--;
18096 }
18097
18098 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
18099 {
18100         if (flags & NDR_IN) {
18101         }
18102         if (flags & NDR_OUT) {
18103                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18104         }
18105         return NDR_ERR_SUCCESS;
18106 }
18107
18108 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
18109 {
18110         if (flags & NDR_IN) {
18111         }
18112         if (flags & NDR_OUT) {
18113                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18114         }
18115         return NDR_ERR_SUCCESS;
18116 }
18117
18118 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
18119 {
18120         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
18121         ndr->depth++;
18122         if (flags & NDR_SET_VALUES) {
18123                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18124         }
18125         if (flags & NDR_IN) {
18126                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
18127                 ndr->depth++;
18128                 ndr->depth--;
18129         }
18130         if (flags & NDR_OUT) {
18131                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
18132                 ndr->depth++;
18133                 ndr_print_WERROR(ndr, "result", r->out.result);
18134                 ndr->depth--;
18135         }
18136         ndr->depth--;
18137 }
18138
18139 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
18140 {
18141         if (flags & NDR_IN) {
18142         }
18143         if (flags & NDR_OUT) {
18144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18145         }
18146         return NDR_ERR_SUCCESS;
18147 }
18148
18149 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
18150 {
18151         if (flags & NDR_IN) {
18152         }
18153         if (flags & NDR_OUT) {
18154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18155         }
18156         return NDR_ERR_SUCCESS;
18157 }
18158
18159 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
18160 {
18161         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
18162         ndr->depth++;
18163         if (flags & NDR_SET_VALUES) {
18164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18165         }
18166         if (flags & NDR_IN) {
18167                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
18168                 ndr->depth++;
18169                 ndr->depth--;
18170         }
18171         if (flags & NDR_OUT) {
18172                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
18173                 ndr->depth++;
18174                 ndr_print_WERROR(ndr, "result", r->out.result);
18175                 ndr->depth--;
18176         }
18177         ndr->depth--;
18178 }
18179
18180 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
18181 {
18182         if (flags & NDR_IN) {
18183         }
18184         if (flags & NDR_OUT) {
18185                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18186         }
18187         return NDR_ERR_SUCCESS;
18188 }
18189
18190 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
18191 {
18192         if (flags & NDR_IN) {
18193         }
18194         if (flags & NDR_OUT) {
18195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18196         }
18197         return NDR_ERR_SUCCESS;
18198 }
18199
18200 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
18201 {
18202         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
18203         ndr->depth++;
18204         if (flags & NDR_SET_VALUES) {
18205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18206         }
18207         if (flags & NDR_IN) {
18208                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
18209                 ndr->depth++;
18210                 ndr->depth--;
18211         }
18212         if (flags & NDR_OUT) {
18213                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
18214                 ndr->depth++;
18215                 ndr_print_WERROR(ndr, "result", r->out.result);
18216                 ndr->depth--;
18217         }
18218         ndr->depth--;
18219 }
18220
18221 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
18222 {
18223         if (flags & NDR_IN) {
18224         }
18225         if (flags & NDR_OUT) {
18226                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18227         }
18228         return NDR_ERR_SUCCESS;
18229 }
18230
18231 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
18232 {
18233         if (flags & NDR_IN) {
18234         }
18235         if (flags & NDR_OUT) {
18236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18237         }
18238         return NDR_ERR_SUCCESS;
18239 }
18240
18241 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
18242 {
18243         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
18244         ndr->depth++;
18245         if (flags & NDR_SET_VALUES) {
18246                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18247         }
18248         if (flags & NDR_IN) {
18249                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
18250                 ndr->depth++;
18251                 ndr->depth--;
18252         }
18253         if (flags & NDR_OUT) {
18254                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
18255                 ndr->depth++;
18256                 ndr_print_WERROR(ndr, "result", r->out.result);
18257                 ndr->depth--;
18258         }
18259         ndr->depth--;
18260 }
18261
18262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
18263 {
18264         if (flags & NDR_IN) {
18265                 if (r->in.handle == NULL) {
18266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18267                 }
18268                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18269                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
18270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
18271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
18272                 if (r->in.local_machine) {
18273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
18274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
18276                         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));
18277                 }
18278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
18279                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
18280                 if (r->in.notify_options) {
18281                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
18282                 }
18283         }
18284         if (flags & NDR_OUT) {
18285                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18286         }
18287         return NDR_ERR_SUCCESS;
18288 }
18289
18290 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
18291 {
18292         uint32_t _ptr_local_machine;
18293         uint32_t _ptr_notify_options;
18294         TALLOC_CTX *_mem_save_handle_0;
18295         TALLOC_CTX *_mem_save_local_machine_0;
18296         TALLOC_CTX *_mem_save_notify_options_0;
18297         if (flags & NDR_IN) {
18298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18299                         NDR_PULL_ALLOC(ndr, r->in.handle);
18300                 }
18301                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18303                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18305                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
18306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
18307                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
18308                 if (_ptr_local_machine) {
18309                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
18310                 } else {
18311                         r->in.local_machine = NULL;
18312                 }
18313                 if (r->in.local_machine) {
18314                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
18315                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
18316                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
18317                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
18318                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
18319                                 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));
18320                         }
18321                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
18322                         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));
18323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
18324                 }
18325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
18326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
18327                 if (_ptr_notify_options) {
18328                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
18329                 } else {
18330                         r->in.notify_options = NULL;
18331                 }
18332                 if (r->in.notify_options) {
18333                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
18334                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
18335                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
18336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
18337                 }
18338         }
18339         if (flags & NDR_OUT) {
18340                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18341         }
18342         return NDR_ERR_SUCCESS;
18343 }
18344
18345 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
18346 {
18347         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
18348         ndr->depth++;
18349         if (flags & NDR_SET_VALUES) {
18350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18351         }
18352         if (flags & NDR_IN) {
18353                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
18354                 ndr->depth++;
18355                 ndr_print_ptr(ndr, "handle", r->in.handle);
18356                 ndr->depth++;
18357                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18358                 ndr->depth--;
18359                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
18360                 ndr_print_uint32(ndr, "options", r->in.options);
18361                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
18362                 ndr->depth++;
18363                 if (r->in.local_machine) {
18364                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
18365                 }
18366                 ndr->depth--;
18367                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
18368                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
18369                 ndr->depth++;
18370                 if (r->in.notify_options) {
18371                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
18372                 }
18373                 ndr->depth--;
18374                 ndr->depth--;
18375         }
18376         if (flags & NDR_OUT) {
18377                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
18378                 ndr->depth++;
18379                 ndr_print_WERROR(ndr, "result", r->out.result);
18380                 ndr->depth--;
18381         }
18382         ndr->depth--;
18383 }
18384
18385 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
18386 {
18387         if (flags & NDR_IN) {
18388                 if (r->in.handle == NULL) {
18389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18390                 }
18391                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
18393                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
18394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
18395                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
18396                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18397         }
18398         if (flags & NDR_OUT) {
18399                 if (r->out.reply_result == NULL) {
18400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18401                 }
18402                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
18403                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18404         }
18405         return NDR_ERR_SUCCESS;
18406 }
18407
18408 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
18409 {
18410         TALLOC_CTX *_mem_save_handle_0;
18411         TALLOC_CTX *_mem_save_reply_result_0;
18412         if (flags & NDR_IN) {
18413                 ZERO_STRUCT(r->out);
18414
18415                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18416                         NDR_PULL_ALLOC(ndr, r->in.handle);
18417                 }
18418                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18419                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18420                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
18423                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
18424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
18425                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
18426                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18427                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
18428                 ZERO_STRUCTP(r->out.reply_result);
18429         }
18430         if (flags & NDR_OUT) {
18431                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18432                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
18433                 }
18434                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
18435                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
18436                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
18437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
18438                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18439         }
18440         return NDR_ERR_SUCCESS;
18441 }
18442
18443 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
18444 {
18445         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
18446         ndr->depth++;
18447         if (flags & NDR_SET_VALUES) {
18448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18449         }
18450         if (flags & NDR_IN) {
18451                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
18452                 ndr->depth++;
18453                 ndr_print_ptr(ndr, "handle", r->in.handle);
18454                 ndr->depth++;
18455                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18456                 ndr->depth--;
18457                 ndr_print_uint32(ndr, "color", r->in.color);
18458                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
18459                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
18460                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
18461                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
18462                 ndr->depth--;
18463         }
18464         if (flags & NDR_OUT) {
18465                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
18466                 ndr->depth++;
18467                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
18468                 ndr->depth++;
18469                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
18470                 ndr->depth--;
18471                 ndr_print_WERROR(ndr, "result", r->out.result);
18472                 ndr->depth--;
18473         }
18474         ndr->depth--;
18475 }
18476
18477 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
18478 {
18479         if (flags & NDR_IN) {
18480                 if (r->in.handle == NULL) {
18481                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18482                 }
18483                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
18485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
18486                 if (r->in.options) {
18487                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
18488                 }
18489         }
18490         if (flags & NDR_OUT) {
18491                 if (r->out.info == NULL) {
18492                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18493                 }
18494                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
18495                 if (*r->out.info) {
18496                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
18497                 }
18498                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18499         }
18500         return NDR_ERR_SUCCESS;
18501 }
18502
18503 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
18504 {
18505         uint32_t _ptr_options;
18506         uint32_t _ptr_info;
18507         TALLOC_CTX *_mem_save_handle_0;
18508         TALLOC_CTX *_mem_save_options_0;
18509         TALLOC_CTX *_mem_save_info_0;
18510         TALLOC_CTX *_mem_save_info_1;
18511         if (flags & NDR_IN) {
18512                 ZERO_STRUCT(r->out);
18513
18514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18515                         NDR_PULL_ALLOC(ndr, r->in.handle);
18516                 }
18517                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18518                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18519                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
18522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
18523                 if (_ptr_options) {
18524                         NDR_PULL_ALLOC(ndr, r->in.options);
18525                 } else {
18526                         r->in.options = NULL;
18527                 }
18528                 if (r->in.options) {
18529                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
18530                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
18531                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
18532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
18533                 }
18534                 NDR_PULL_ALLOC(ndr, r->out.info);
18535                 ZERO_STRUCTP(r->out.info);
18536         }
18537         if (flags & NDR_OUT) {
18538                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18539                         NDR_PULL_ALLOC(ndr, r->out.info);
18540                 }
18541                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18542                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
18543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18544                 if (_ptr_info) {
18545                         NDR_PULL_ALLOC(ndr, *r->out.info);
18546                 } else {
18547                         *r->out.info = NULL;
18548                 }
18549                 if (*r->out.info) {
18550                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
18551                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
18552                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
18553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
18554                 }
18555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
18556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18557         }
18558         return NDR_ERR_SUCCESS;
18559 }
18560
18561 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
18562 {
18563         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
18564         ndr->depth++;
18565         if (flags & NDR_SET_VALUES) {
18566                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18567         }
18568         if (flags & NDR_IN) {
18569                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
18570                 ndr->depth++;
18571                 ndr_print_ptr(ndr, "handle", r->in.handle);
18572                 ndr->depth++;
18573                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18574                 ndr->depth--;
18575                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
18576                 ndr_print_ptr(ndr, "options", r->in.options);
18577                 ndr->depth++;
18578                 if (r->in.options) {
18579                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
18580                 }
18581                 ndr->depth--;
18582                 ndr->depth--;
18583         }
18584         if (flags & NDR_OUT) {
18585                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
18586                 ndr->depth++;
18587                 ndr_print_ptr(ndr, "info", r->out.info);
18588                 ndr->depth++;
18589                 ndr_print_ptr(ndr, "info", *r->out.info);
18590                 ndr->depth++;
18591                 if (*r->out.info) {
18592                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
18593                 }
18594                 ndr->depth--;
18595                 ndr->depth--;
18596                 ndr_print_WERROR(ndr, "result", r->out.result);
18597                 ndr->depth--;
18598         }
18599         ndr->depth--;
18600 }
18601
18602 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
18603 {
18604         if (flags & NDR_IN) {
18605         }
18606         if (flags & NDR_OUT) {
18607                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18608         }
18609         return NDR_ERR_SUCCESS;
18610 }
18611
18612 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
18613 {
18614         if (flags & NDR_IN) {
18615         }
18616         if (flags & NDR_OUT) {
18617                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18618         }
18619         return NDR_ERR_SUCCESS;
18620 }
18621
18622 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
18623 {
18624         ndr_print_struct(ndr, name, "spoolss_44");
18625         ndr->depth++;
18626         if (flags & NDR_SET_VALUES) {
18627                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18628         }
18629         if (flags & NDR_IN) {
18630                 ndr_print_struct(ndr, "in", "spoolss_44");
18631                 ndr->depth++;
18632                 ndr->depth--;
18633         }
18634         if (flags & NDR_OUT) {
18635                 ndr_print_struct(ndr, "out", "spoolss_44");
18636                 ndr->depth++;
18637                 ndr_print_WERROR(ndr, "result", r->out.result);
18638                 ndr->depth--;
18639         }
18640         ndr->depth--;
18641 }
18642
18643 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
18644 {
18645         if (flags & NDR_IN) {
18646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18647                 if (r->in.printername) {
18648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18650                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18651                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18652                 }
18653                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18654                 if (r->in.datatype) {
18655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18659                 }
18660                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
18662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
18664                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
18665         }
18666         if (flags & NDR_OUT) {
18667                 if (r->out.handle == NULL) {
18668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18669                 }
18670                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18671                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18672         }
18673         return NDR_ERR_SUCCESS;
18674 }
18675
18676 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
18677 {
18678         uint32_t _ptr_printername;
18679         uint32_t _ptr_datatype;
18680         TALLOC_CTX *_mem_save_printername_0;
18681         TALLOC_CTX *_mem_save_datatype_0;
18682         TALLOC_CTX *_mem_save_handle_0;
18683         if (flags & NDR_IN) {
18684                 ZERO_STRUCT(r->out);
18685
18686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18687                 if (_ptr_printername) {
18688                         NDR_PULL_ALLOC(ndr, r->in.printername);
18689                 } else {
18690                         r->in.printername = NULL;
18691                 }
18692                 if (r->in.printername) {
18693                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18694                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18695                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18696                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18697                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18698                                 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));
18699                         }
18700                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18701                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18702                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18703                 }
18704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18705                 if (_ptr_datatype) {
18706                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18707                 } else {
18708                         r->in.datatype = NULL;
18709                 }
18710                 if (r->in.datatype) {
18711                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18712                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18715                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18716                                 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));
18717                         }
18718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18721                 }
18722                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
18724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18725                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
18726                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
18727                 NDR_PULL_ALLOC(ndr, r->out.handle);
18728                 ZERO_STRUCTP(r->out.handle);
18729         }
18730         if (flags & NDR_OUT) {
18731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18732                         NDR_PULL_ALLOC(ndr, r->out.handle);
18733                 }
18734                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18735                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18738                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18739         }
18740         return NDR_ERR_SUCCESS;
18741 }
18742
18743 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
18744 {
18745         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
18746         ndr->depth++;
18747         if (flags & NDR_SET_VALUES) {
18748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18749         }
18750         if (flags & NDR_IN) {
18751                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
18752                 ndr->depth++;
18753                 ndr_print_ptr(ndr, "printername", r->in.printername);
18754                 ndr->depth++;
18755                 if (r->in.printername) {
18756                         ndr_print_string(ndr, "printername", r->in.printername);
18757                 }
18758                 ndr->depth--;
18759                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18760                 ndr->depth++;
18761                 if (r->in.datatype) {
18762                         ndr_print_string(ndr, "datatype", r->in.datatype);
18763                 }
18764                 ndr->depth--;
18765                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18766                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
18767                 ndr_print_uint32(ndr, "level", r->in.level);
18768                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
18769                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
18770                 ndr->depth--;
18771         }
18772         if (flags & NDR_OUT) {
18773                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
18774                 ndr->depth++;
18775                 ndr_print_ptr(ndr, "handle", r->out.handle);
18776                 ndr->depth++;
18777                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18778                 ndr->depth--;
18779                 ndr_print_WERROR(ndr, "result", r->out.result);
18780                 ndr->depth--;
18781         }
18782         ndr->depth--;
18783 }
18784
18785 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
18786 {
18787         if (flags & NDR_IN) {
18788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18789                 if (r->in.server) {
18790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18793                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18794                 }
18795                 if (r->in.info_ctr == NULL) {
18796                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18797                 }
18798                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
18799                 if (r->in.devmode_ctr == NULL) {
18800                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18801                 }
18802                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
18803                 if (r->in.secdesc_ctr == NULL) {
18804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18805                 }
18806                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
18807                 if (r->in.userlevel_ctr == NULL) {
18808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18809                 }
18810                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
18811         }
18812         if (flags & NDR_OUT) {
18813                 if (r->out.handle == NULL) {
18814                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18815                 }
18816                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18817                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18818         }
18819         return NDR_ERR_SUCCESS;
18820 }
18821
18822 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
18823 {
18824         uint32_t _ptr_server;
18825         TALLOC_CTX *_mem_save_server_0;
18826         TALLOC_CTX *_mem_save_info_ctr_0;
18827         TALLOC_CTX *_mem_save_devmode_ctr_0;
18828         TALLOC_CTX *_mem_save_secdesc_ctr_0;
18829         TALLOC_CTX *_mem_save_userlevel_ctr_0;
18830         TALLOC_CTX *_mem_save_handle_0;
18831         if (flags & NDR_IN) {
18832                 ZERO_STRUCT(r->out);
18833
18834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18835                 if (_ptr_server) {
18836                         NDR_PULL_ALLOC(ndr, r->in.server);
18837                 } else {
18838                         r->in.server = NULL;
18839                 }
18840                 if (r->in.server) {
18841                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18842                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18843                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18844                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18845                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18846                                 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));
18847                         }
18848                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18849                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18851                 }
18852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18853                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
18854                 }
18855                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18856                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
18857                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
18858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
18859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18860                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
18861                 }
18862                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18863                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
18864                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
18865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
18866                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18867                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
18868                 }
18869                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18870                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
18871                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
18872                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
18873                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18874                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
18875                 }
18876                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18877                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
18878                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
18879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
18880                 NDR_PULL_ALLOC(ndr, r->out.handle);
18881                 ZERO_STRUCTP(r->out.handle);
18882         }
18883         if (flags & NDR_OUT) {
18884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18885                         NDR_PULL_ALLOC(ndr, r->out.handle);
18886                 }
18887                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18888                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18889                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18892         }
18893         return NDR_ERR_SUCCESS;
18894 }
18895
18896 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
18897 {
18898         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
18899         ndr->depth++;
18900         if (flags & NDR_SET_VALUES) {
18901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18902         }
18903         if (flags & NDR_IN) {
18904                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
18905                 ndr->depth++;
18906                 ndr_print_ptr(ndr, "server", r->in.server);
18907                 ndr->depth++;
18908                 if (r->in.server) {
18909                         ndr_print_string(ndr, "server", r->in.server);
18910                 }
18911                 ndr->depth--;
18912                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
18913                 ndr->depth++;
18914                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
18915                 ndr->depth--;
18916                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
18917                 ndr->depth++;
18918                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
18919                 ndr->depth--;
18920                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
18921                 ndr->depth++;
18922                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
18923                 ndr->depth--;
18924                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
18925                 ndr->depth++;
18926                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
18927                 ndr->depth--;
18928                 ndr->depth--;
18929         }
18930         if (flags & NDR_OUT) {
18931                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
18932                 ndr->depth++;
18933                 ndr_print_ptr(ndr, "handle", r->out.handle);
18934                 ndr->depth++;
18935                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18936                 ndr->depth--;
18937                 ndr_print_WERROR(ndr, "result", r->out.result);
18938                 ndr->depth--;
18939         }
18940         ndr->depth--;
18941 }
18942
18943 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
18944 {
18945         if (flags & NDR_IN) {
18946         }
18947         if (flags & NDR_OUT) {
18948                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18949         }
18950         return NDR_ERR_SUCCESS;
18951 }
18952
18953 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
18954 {
18955         if (flags & NDR_IN) {
18956         }
18957         if (flags & NDR_OUT) {
18958                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18959         }
18960         return NDR_ERR_SUCCESS;
18961 }
18962
18963 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
18964 {
18965         ndr_print_struct(ndr, name, "spoolss_47");
18966         ndr->depth++;
18967         if (flags & NDR_SET_VALUES) {
18968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18969         }
18970         if (flags & NDR_IN) {
18971                 ndr_print_struct(ndr, "in", "spoolss_47");
18972                 ndr->depth++;
18973                 ndr->depth--;
18974         }
18975         if (flags & NDR_OUT) {
18976                 ndr_print_struct(ndr, "out", "spoolss_47");
18977                 ndr->depth++;
18978                 ndr_print_WERROR(ndr, "result", r->out.result);
18979                 ndr->depth--;
18980         }
18981         ndr->depth--;
18982 }
18983
18984 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
18985 {
18986         if (flags & NDR_IN) {
18987                 if (r->in.handle == NULL) {
18988                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18989                 }
18990                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
18992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
18993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
18994         }
18995         if (flags & NDR_OUT) {
18996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
18997                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
18998                 if (r->out.value_needed == NULL) {
18999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19000                 }
19001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
19002                 if (r->out.printerdata_type == NULL) {
19003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19004                 }
19005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
19006                 if (r->out.buffer == NULL) {
19007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19008                 }
19009                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
19010                 if (r->out.data_needed == NULL) {
19011                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19012                 }
19013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
19014                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19015         }
19016         return NDR_ERR_SUCCESS;
19017 }
19018
19019 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
19020 {
19021         TALLOC_CTX *_mem_save_handle_0;
19022         TALLOC_CTX *_mem_save_value_needed_0;
19023         TALLOC_CTX *_mem_save_printerdata_type_0;
19024         TALLOC_CTX *_mem_save_buffer_0;
19025         TALLOC_CTX *_mem_save_data_needed_0;
19026         if (flags & NDR_IN) {
19027                 ZERO_STRUCT(r->out);
19028
19029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19030                         NDR_PULL_ALLOC(ndr, r->in.handle);
19031                 }
19032                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19033                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19034                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
19037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
19038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
19039                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
19040                 ZERO_STRUCTP(r->out.value_needed);
19041                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
19042                 ZERO_STRUCTP(r->out.printerdata_type);
19043                 NDR_PULL_ALLOC(ndr, r->out.buffer);
19044                 ZERO_STRUCTP(r->out.buffer);
19045                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
19046                 ZERO_STRUCTP(r->out.data_needed);
19047         }
19048         if (flags & NDR_OUT) {
19049                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
19050                 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));
19051                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19052                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
19053                 }
19054                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19055                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
19056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
19057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
19058                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19059                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
19060                 }
19061                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
19062                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
19063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
19064                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
19065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19066                         NDR_PULL_ALLOC(ndr, r->out.buffer);
19067                 }
19068                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19069                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
19070                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
19071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
19072                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19073                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
19074                 }
19075                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19076                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
19077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
19078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
19079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19080                 if (r->out.value_name) {
19081                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
19082                 }
19083         }
19084         return NDR_ERR_SUCCESS;
19085 }
19086
19087 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
19088 {
19089         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
19090         ndr->depth++;
19091         if (flags & NDR_SET_VALUES) {
19092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19093         }
19094         if (flags & NDR_IN) {
19095                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
19096                 ndr->depth++;
19097                 ndr_print_ptr(ndr, "handle", r->in.handle);
19098                 ndr->depth++;
19099                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19100                 ndr->depth--;
19101                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
19102                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
19103                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
19104                 ndr->depth--;
19105         }
19106         if (flags & NDR_OUT) {
19107                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
19108                 ndr->depth++;
19109                 ndr_print_string(ndr, "value_name", r->out.value_name);
19110                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
19111                 ndr->depth++;
19112                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
19113                 ndr->depth--;
19114                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
19115                 ndr->depth++;
19116                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
19117                 ndr->depth--;
19118                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
19119                 ndr->depth++;
19120                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
19121                 ndr->depth--;
19122                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
19123                 ndr->depth++;
19124                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
19125                 ndr->depth--;
19126                 ndr_print_WERROR(ndr, "result", r->out.result);
19127                 ndr->depth--;
19128         }
19129         ndr->depth--;
19130 }
19131
19132 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
19133 {
19134         if (flags & NDR_IN) {
19135                 if (r->in.handle == NULL) {
19136                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19137                 }
19138                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19142                 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));
19143         }
19144         if (flags & NDR_OUT) {
19145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19146         }
19147         return NDR_ERR_SUCCESS;
19148 }
19149
19150 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
19151 {
19152         TALLOC_CTX *_mem_save_handle_0;
19153         if (flags & NDR_IN) {
19154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19155                         NDR_PULL_ALLOC(ndr, r->in.handle);
19156                 }
19157                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19158                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19159                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19161                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
19162                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
19163                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
19164                         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));
19165                 }
19166                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
19167                 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));
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_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
19176 {
19177         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
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_DeletePrinterData");
19184                 ndr->depth++;
19185                 ndr_print_ptr(ndr, "handle", r->in.handle);
19186                 ndr->depth++;
19187                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19188                 ndr->depth--;
19189                 ndr_print_string(ndr, "value_name", r->in.value_name);
19190                 ndr->depth--;
19191         }
19192         if (flags & NDR_OUT) {
19193                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
19194                 ndr->depth++;
19195                 ndr_print_WERROR(ndr, "result", r->out.result);
19196                 ndr->depth--;
19197         }
19198         ndr->depth--;
19199 }
19200
19201 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
19202 {
19203         if (flags & NDR_IN) {
19204         }
19205         if (flags & NDR_OUT) {
19206                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19207         }
19208         return NDR_ERR_SUCCESS;
19209 }
19210
19211 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
19212 {
19213         if (flags & NDR_IN) {
19214         }
19215         if (flags & NDR_OUT) {
19216                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19217         }
19218         return NDR_ERR_SUCCESS;
19219 }
19220
19221 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
19222 {
19223         ndr_print_struct(ndr, name, "spoolss_4a");
19224         ndr->depth++;
19225         if (flags & NDR_SET_VALUES) {
19226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19227         }
19228         if (flags & NDR_IN) {
19229                 ndr_print_struct(ndr, "in", "spoolss_4a");
19230                 ndr->depth++;
19231                 ndr->depth--;
19232         }
19233         if (flags & NDR_OUT) {
19234                 ndr_print_struct(ndr, "out", "spoolss_4a");
19235                 ndr->depth++;
19236                 ndr_print_WERROR(ndr, "result", r->out.result);
19237                 ndr->depth--;
19238         }
19239         ndr->depth--;
19240 }
19241
19242 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
19243 {
19244         if (flags & NDR_IN) {
19245         }
19246         if (flags & NDR_OUT) {
19247                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19248         }
19249         return NDR_ERR_SUCCESS;
19250 }
19251
19252 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
19253 {
19254         if (flags & NDR_IN) {
19255         }
19256         if (flags & NDR_OUT) {
19257                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19258         }
19259         return NDR_ERR_SUCCESS;
19260 }
19261
19262 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
19263 {
19264         ndr_print_struct(ndr, name, "spoolss_4b");
19265         ndr->depth++;
19266         if (flags & NDR_SET_VALUES) {
19267                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19268         }
19269         if (flags & NDR_IN) {
19270                 ndr_print_struct(ndr, "in", "spoolss_4b");
19271                 ndr->depth++;
19272                 ndr->depth--;
19273         }
19274         if (flags & NDR_OUT) {
19275                 ndr_print_struct(ndr, "out", "spoolss_4b");
19276                 ndr->depth++;
19277                 ndr_print_WERROR(ndr, "result", r->out.result);
19278                 ndr->depth--;
19279         }
19280         ndr->depth--;
19281 }
19282
19283 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
19284 {
19285         if (flags & NDR_IN) {
19286         }
19287         if (flags & NDR_OUT) {
19288                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19289         }
19290         return NDR_ERR_SUCCESS;
19291 }
19292
19293 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
19294 {
19295         if (flags & NDR_IN) {
19296         }
19297         if (flags & NDR_OUT) {
19298                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19299         }
19300         return NDR_ERR_SUCCESS;
19301 }
19302
19303 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
19304 {
19305         ndr_print_struct(ndr, name, "spoolss_4c");
19306         ndr->depth++;
19307         if (flags & NDR_SET_VALUES) {
19308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19309         }
19310         if (flags & NDR_IN) {
19311                 ndr_print_struct(ndr, "in", "spoolss_4c");
19312                 ndr->depth++;
19313                 ndr->depth--;
19314         }
19315         if (flags & NDR_OUT) {
19316                 ndr_print_struct(ndr, "out", "spoolss_4c");
19317                 ndr->depth++;
19318                 ndr_print_WERROR(ndr, "result", r->out.result);
19319                 ndr->depth--;
19320         }
19321         ndr->depth--;
19322 }
19323
19324 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
19325 {
19326         if (flags & NDR_IN) {
19327                 if (r->in.handle == NULL) {
19328                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19329                 }
19330                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19334                 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));
19335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19338                 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));
19339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
19340                 if (r->in.buffer == NULL) {
19341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19342                 }
19343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19344                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
19345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19346         }
19347         if (flags & NDR_OUT) {
19348                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19349         }
19350         return NDR_ERR_SUCCESS;
19351 }
19352
19353 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
19354 {
19355         TALLOC_CTX *_mem_save_handle_0;
19356         if (flags & NDR_IN) {
19357                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19358                         NDR_PULL_ALLOC(ndr, r->in.handle);
19359                 }
19360                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19361                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19362                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19364                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
19365                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
19366                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
19367                         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));
19368                 }
19369                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
19370                 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));
19371                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
19372                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
19373                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
19374                         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));
19375                 }
19376                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
19377                 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));
19378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
19379                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
19380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19381                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
19382                 }
19383                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
19384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19385                 if (r->in.buffer) {
19386                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
19387                 }
19388         }
19389         if (flags & NDR_OUT) {
19390                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19391         }
19392         return NDR_ERR_SUCCESS;
19393 }
19394
19395 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
19396 {
19397         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
19398         ndr->depth++;
19399         if (flags & NDR_SET_VALUES) {
19400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19401         }
19402         if (flags & NDR_IN) {
19403                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
19404                 ndr->depth++;
19405                 ndr_print_ptr(ndr, "handle", r->in.handle);
19406                 ndr->depth++;
19407                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19408                 ndr->depth--;
19409                 ndr_print_string(ndr, "key_name", r->in.key_name);
19410                 ndr_print_string(ndr, "value_name", r->in.value_name);
19411                 ndr_print_uint32(ndr, "type", r->in.type);
19412                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19413                 ndr->depth++;
19414                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
19415                 ndr->depth--;
19416                 ndr_print_uint32(ndr, "offered", r->in.offered);
19417                 ndr->depth--;
19418         }
19419         if (flags & NDR_OUT) {
19420                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
19421                 ndr->depth++;
19422                 ndr_print_WERROR(ndr, "result", r->out.result);
19423                 ndr->depth--;
19424         }
19425         ndr->depth--;
19426 }
19427
19428 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
19429 {
19430         if (flags & NDR_IN) {
19431                 if (r->in.handle == NULL) {
19432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19433                 }
19434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19438                 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));
19439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19442                 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));
19443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19444         }
19445         if (flags & NDR_OUT) {
19446                 if (r->out.type == NULL) {
19447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19448                 }
19449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
19450                 if (r->out.buffer == NULL) {
19451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19452                 }
19453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19454                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
19455                 if (r->out.needed == NULL) {
19456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19457                 }
19458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19459                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19460         }
19461         return NDR_ERR_SUCCESS;
19462 }
19463
19464 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
19465 {
19466         TALLOC_CTX *_mem_save_handle_0;
19467         TALLOC_CTX *_mem_save_type_0;
19468         TALLOC_CTX *_mem_save_needed_0;
19469         if (flags & NDR_IN) {
19470                 ZERO_STRUCT(r->out);
19471
19472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19473                         NDR_PULL_ALLOC(ndr, r->in.handle);
19474                 }
19475                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19479                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
19480                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
19481                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
19482                         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));
19483                 }
19484                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
19485                 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));
19486                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
19487                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
19488                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
19489                         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));
19490                 }
19491                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
19492                 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));
19493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19494                 NDR_PULL_ALLOC(ndr, r->out.type);
19495                 ZERO_STRUCTP(r->out.type);
19496                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
19497                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
19498                 NDR_PULL_ALLOC(ndr, r->out.needed);
19499                 ZERO_STRUCTP(r->out.needed);
19500         }
19501         if (flags & NDR_OUT) {
19502                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19503                         NDR_PULL_ALLOC(ndr, r->out.type);
19504                 }
19505                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
19506                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
19507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
19508                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
19509                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
19510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19511                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
19512                 }
19513                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
19514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19515                         NDR_PULL_ALLOC(ndr, r->out.needed);
19516                 }
19517                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19518                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19521                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19522                 if (r->out.buffer) {
19523                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
19524                 }
19525         }
19526         return NDR_ERR_SUCCESS;
19527 }
19528
19529 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
19530 {
19531         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
19532         ndr->depth++;
19533         if (flags & NDR_SET_VALUES) {
19534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19535         }
19536         if (flags & NDR_IN) {
19537                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
19538                 ndr->depth++;
19539                 ndr_print_ptr(ndr, "handle", r->in.handle);
19540                 ndr->depth++;
19541                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19542                 ndr->depth--;
19543                 ndr_print_string(ndr, "key_name", r->in.key_name);
19544                 ndr_print_string(ndr, "value_name", r->in.value_name);
19545                 ndr_print_uint32(ndr, "offered", r->in.offered);
19546                 ndr->depth--;
19547         }
19548         if (flags & NDR_OUT) {
19549                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
19550                 ndr->depth++;
19551                 ndr_print_ptr(ndr, "type", r->out.type);
19552                 ndr->depth++;
19553                 ndr_print_uint32(ndr, "type", *r->out.type);
19554                 ndr->depth--;
19555                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
19556                 ndr->depth++;
19557                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
19558                 ndr->depth--;
19559                 ndr_print_ptr(ndr, "needed", r->out.needed);
19560                 ndr->depth++;
19561                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19562                 ndr->depth--;
19563                 ndr_print_WERROR(ndr, "result", r->out.result);
19564                 ndr->depth--;
19565         }
19566         ndr->depth--;
19567 }
19568
19569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
19570 {
19571         if (flags & NDR_IN) {
19572                 if (r->in.handle == NULL) {
19573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19574                 }
19575                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19579                 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));
19580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19581         }
19582         if (flags & NDR_OUT) {
19583                 if (r->out.buffer == NULL) {
19584                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19585                 }
19586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19587                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
19588                 if (r->out.needed == NULL) {
19589                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19590                 }
19591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19592                 if (r->out.count == NULL) {
19593                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19594                 }
19595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19597         }
19598         return NDR_ERR_SUCCESS;
19599 }
19600
19601 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
19602 {
19603         TALLOC_CTX *_mem_save_handle_0;
19604         TALLOC_CTX *_mem_save_needed_0;
19605         TALLOC_CTX *_mem_save_count_0;
19606         if (flags & NDR_IN) {
19607                 ZERO_STRUCT(r->out);
19608
19609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19610                         NDR_PULL_ALLOC(ndr, r->in.handle);
19611                 }
19612                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19613                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19614                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19616                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
19617                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
19618                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
19619                         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));
19620                 }
19621                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
19622                 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));
19623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19624                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
19625                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
19626                 NDR_PULL_ALLOC(ndr, r->out.needed);
19627                 ZERO_STRUCTP(r->out.needed);
19628                 NDR_PULL_ALLOC(ndr, r->out.count);
19629                 ZERO_STRUCTP(r->out.count);
19630         }
19631         if (flags & NDR_OUT) {
19632                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
19633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19634                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
19635                 }
19636                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
19637                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19638                         NDR_PULL_ALLOC(ndr, r->out.needed);
19639                 }
19640                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19641                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19643                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19644                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19645                         NDR_PULL_ALLOC(ndr, r->out.count);
19646                 }
19647                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19648                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19650                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19651                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19652                 if (r->out.buffer) {
19653                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
19654                 }
19655         }
19656         return NDR_ERR_SUCCESS;
19657 }
19658
19659 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
19660 {
19661         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
19662         ndr->depth++;
19663         if (flags & NDR_SET_VALUES) {
19664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19665         }
19666         if (flags & NDR_IN) {
19667                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
19668                 ndr->depth++;
19669                 ndr_print_ptr(ndr, "handle", r->in.handle);
19670                 ndr->depth++;
19671                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19672                 ndr->depth--;
19673                 ndr_print_string(ndr, "key_name", r->in.key_name);
19674                 ndr_print_uint32(ndr, "offered", r->in.offered);
19675                 ndr->depth--;
19676         }
19677         if (flags & NDR_OUT) {
19678                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
19679                 ndr->depth++;
19680                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
19681                 ndr->depth++;
19682                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
19683                 ndr->depth--;
19684                 ndr_print_ptr(ndr, "needed", r->out.needed);
19685                 ndr->depth++;
19686                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19687                 ndr->depth--;
19688                 ndr_print_ptr(ndr, "count", r->out.count);
19689                 ndr->depth++;
19690                 ndr_print_uint32(ndr, "count", *r->out.count);
19691                 ndr->depth--;
19692                 ndr_print_WERROR(ndr, "result", r->out.result);
19693                 ndr->depth--;
19694         }
19695         ndr->depth--;
19696 }
19697
19698 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
19699 {
19700         uint32_t cntr_key_buffer_1;
19701         if (flags & NDR_IN) {
19702                 if (r->in.handle == NULL) {
19703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19704                 }
19705                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19709                 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));
19710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
19711         }
19712         if (flags & NDR_OUT) {
19713                 if (r->out.key_buffer == NULL) {
19714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19715                 }
19716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
19717                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
19718                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
19719                 }
19720                 if (r->out.needed == NULL) {
19721                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19722                 }
19723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19724                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19725         }
19726         return NDR_ERR_SUCCESS;
19727 }
19728
19729 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
19730 {
19731         uint32_t cntr_key_buffer_1;
19732         TALLOC_CTX *_mem_save_handle_0;
19733         TALLOC_CTX *_mem_save_key_buffer_1;
19734         TALLOC_CTX *_mem_save_needed_0;
19735         if (flags & NDR_IN) {
19736                 ZERO_STRUCT(r->out);
19737
19738                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19739                         NDR_PULL_ALLOC(ndr, r->in.handle);
19740                 }
19741                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19742                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19743                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19744                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19745                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
19746                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
19747                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
19748                         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));
19749                 }
19750                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
19751                 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));
19752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
19753                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
19754                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
19755                 NDR_PULL_ALLOC(ndr, r->out.needed);
19756                 ZERO_STRUCTP(r->out.needed);
19757         }
19758         if (flags & NDR_OUT) {
19759                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
19760                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19761                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
19762                 }
19763                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
19764                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
19765                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
19766                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
19767                 }
19768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
19769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19770                         NDR_PULL_ALLOC(ndr, r->out.needed);
19771                 }
19772                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19773                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19776                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19777                 if (r->out.key_buffer) {
19778                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
19779                 }
19780         }
19781         return NDR_ERR_SUCCESS;
19782 }
19783
19784 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
19785 {
19786         uint32_t cntr_key_buffer_1;
19787         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
19788         ndr->depth++;
19789         if (flags & NDR_SET_VALUES) {
19790                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19791         }
19792         if (flags & NDR_IN) {
19793                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
19794                 ndr->depth++;
19795                 ndr_print_ptr(ndr, "handle", r->in.handle);
19796                 ndr->depth++;
19797                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19798                 ndr->depth--;
19799                 ndr_print_string(ndr, "key_name", r->in.key_name);
19800                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
19801                 ndr->depth--;
19802         }
19803         if (flags & NDR_OUT) {
19804                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
19805                 ndr->depth++;
19806                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
19807                 ndr->depth++;
19808                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
19809                 ndr->depth++;
19810                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
19811                         char *idx_1=NULL;
19812                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
19813                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
19814                                 free(idx_1);
19815                         }
19816                 }
19817                 ndr->depth--;
19818                 ndr->depth--;
19819                 ndr_print_ptr(ndr, "needed", r->out.needed);
19820                 ndr->depth++;
19821                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19822                 ndr->depth--;
19823                 ndr_print_WERROR(ndr, "result", r->out.result);
19824                 ndr->depth--;
19825         }
19826         ndr->depth--;
19827 }
19828
19829 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
19830 {
19831         if (flags & NDR_IN) {
19832                 if (r->in.handle == NULL) {
19833                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19834                 }
19835                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19839                 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));
19840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19843                 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));
19844         }
19845         if (flags & NDR_OUT) {
19846                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19847         }
19848         return NDR_ERR_SUCCESS;
19849 }
19850
19851 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
19852 {
19853         TALLOC_CTX *_mem_save_handle_0;
19854         if (flags & NDR_IN) {
19855                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19856                         NDR_PULL_ALLOC(ndr, r->in.handle);
19857                 }
19858                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19859                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19860                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19861                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19862                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
19863                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
19864                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
19865                         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));
19866                 }
19867                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
19868                 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));
19869                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
19870                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
19871                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
19872                         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));
19873                 }
19874                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
19875                 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));
19876         }
19877         if (flags & NDR_OUT) {
19878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19879         }
19880         return NDR_ERR_SUCCESS;
19881 }
19882
19883 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
19884 {
19885         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
19886         ndr->depth++;
19887         if (flags & NDR_SET_VALUES) {
19888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19889         }
19890         if (flags & NDR_IN) {
19891                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
19892                 ndr->depth++;
19893                 ndr_print_ptr(ndr, "handle", r->in.handle);
19894                 ndr->depth++;
19895                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19896                 ndr->depth--;
19897                 ndr_print_string(ndr, "key_name", r->in.key_name);
19898                 ndr_print_string(ndr, "value_name", r->in.value_name);
19899                 ndr->depth--;
19900         }
19901         if (flags & NDR_OUT) {
19902                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
19903                 ndr->depth++;
19904                 ndr_print_WERROR(ndr, "result", r->out.result);
19905                 ndr->depth--;
19906         }
19907         ndr->depth--;
19908 }
19909
19910 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
19911 {
19912         if (flags & NDR_IN) {
19913                 if (r->in.handle == NULL) {
19914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19915                 }
19916                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
19920                 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));
19921         }
19922         if (flags & NDR_OUT) {
19923                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19924         }
19925         return NDR_ERR_SUCCESS;
19926 }
19927
19928 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
19929 {
19930         TALLOC_CTX *_mem_save_handle_0;
19931         if (flags & NDR_IN) {
19932                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19933                         NDR_PULL_ALLOC(ndr, r->in.handle);
19934                 }
19935                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19936                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19937                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19938                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19939                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
19940                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
19941                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
19942                         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));
19943                 }
19944                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
19945                 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));
19946         }
19947         if (flags & NDR_OUT) {
19948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19949         }
19950         return NDR_ERR_SUCCESS;
19951 }
19952
19953 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
19954 {
19955         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
19956         ndr->depth++;
19957         if (flags & NDR_SET_VALUES) {
19958                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19959         }
19960         if (flags & NDR_IN) {
19961                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
19962                 ndr->depth++;
19963                 ndr_print_ptr(ndr, "handle", r->in.handle);
19964                 ndr->depth++;
19965                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19966                 ndr->depth--;
19967                 ndr_print_string(ndr, "key_name", r->in.key_name);
19968                 ndr->depth--;
19969         }
19970         if (flags & NDR_OUT) {
19971                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
19972                 ndr->depth++;
19973                 ndr_print_WERROR(ndr, "result", r->out.result);
19974                 ndr->depth--;
19975         }
19976         ndr->depth--;
19977 }
19978
19979 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
19980 {
19981         if (flags & NDR_IN) {
19982         }
19983         if (flags & NDR_OUT) {
19984                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19985         }
19986         return NDR_ERR_SUCCESS;
19987 }
19988
19989 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
19990 {
19991         if (flags & NDR_IN) {
19992         }
19993         if (flags & NDR_OUT) {
19994                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19995         }
19996         return NDR_ERR_SUCCESS;
19997 }
19998
19999 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
20000 {
20001         ndr_print_struct(ndr, name, "spoolss_53");
20002         ndr->depth++;
20003         if (flags & NDR_SET_VALUES) {
20004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20005         }
20006         if (flags & NDR_IN) {
20007                 ndr_print_struct(ndr, "in", "spoolss_53");
20008                 ndr->depth++;
20009                 ndr->depth--;
20010         }
20011         if (flags & NDR_OUT) {
20012                 ndr_print_struct(ndr, "out", "spoolss_53");
20013                 ndr->depth++;
20014                 ndr_print_WERROR(ndr, "result", r->out.result);
20015                 ndr->depth--;
20016         }
20017         ndr->depth--;
20018 }
20019
20020 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
20021 {
20022         if (flags & NDR_IN) {
20023                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20024                 if (r->in.server) {
20025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20029                 }
20030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20033                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20037                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20038                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
20039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
20040         }
20041         if (flags & NDR_OUT) {
20042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20043         }
20044         return NDR_ERR_SUCCESS;
20045 }
20046
20047 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
20048 {
20049         uint32_t _ptr_server;
20050         TALLOC_CTX *_mem_save_server_0;
20051         if (flags & NDR_IN) {
20052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20053                 if (_ptr_server) {
20054                         NDR_PULL_ALLOC(ndr, r->in.server);
20055                 } else {
20056                         r->in.server = NULL;
20057                 }
20058                 if (r->in.server) {
20059                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20060                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20062                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20063                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20064                                 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));
20065                         }
20066                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20067                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20069                 }
20070                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20071                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20072                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20073                         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));
20074                 }
20075                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20076                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20077                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20078                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20079                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20080                         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));
20081                 }
20082                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20083                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20084                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
20085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
20086         }
20087         if (flags & NDR_OUT) {
20088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20089         }
20090         return NDR_ERR_SUCCESS;
20091 }
20092
20093 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
20094 {
20095         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
20096         ndr->depth++;
20097         if (flags & NDR_SET_VALUES) {
20098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20099         }
20100         if (flags & NDR_IN) {
20101                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
20102                 ndr->depth++;
20103                 ndr_print_ptr(ndr, "server", r->in.server);
20104                 ndr->depth++;
20105                 if (r->in.server) {
20106                         ndr_print_string(ndr, "server", r->in.server);
20107                 }
20108                 ndr->depth--;
20109                 ndr_print_string(ndr, "architecture", r->in.architecture);
20110                 ndr_print_string(ndr, "driver", r->in.driver);
20111                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
20112                 ndr_print_uint32(ndr, "version", r->in.version);
20113                 ndr->depth--;
20114         }
20115         if (flags & NDR_OUT) {
20116                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
20117                 ndr->depth++;
20118                 ndr_print_WERROR(ndr, "result", r->out.result);
20119                 ndr->depth--;
20120         }
20121         ndr->depth--;
20122 }
20123
20124 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
20125 {
20126         if (flags & NDR_IN) {
20127         }
20128         if (flags & NDR_OUT) {
20129                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20130         }
20131         return NDR_ERR_SUCCESS;
20132 }
20133
20134 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
20135 {
20136         if (flags & NDR_IN) {
20137         }
20138         if (flags & NDR_OUT) {
20139                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20140         }
20141         return NDR_ERR_SUCCESS;
20142 }
20143
20144 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
20145 {
20146         ndr_print_struct(ndr, name, "spoolss_55");
20147         ndr->depth++;
20148         if (flags & NDR_SET_VALUES) {
20149                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20150         }
20151         if (flags & NDR_IN) {
20152                 ndr_print_struct(ndr, "in", "spoolss_55");
20153                 ndr->depth++;
20154                 ndr->depth--;
20155         }
20156         if (flags & NDR_OUT) {
20157                 ndr_print_struct(ndr, "out", "spoolss_55");
20158                 ndr->depth++;
20159                 ndr_print_WERROR(ndr, "result", r->out.result);
20160                 ndr->depth--;
20161         }
20162         ndr->depth--;
20163 }
20164
20165 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
20166 {
20167         if (flags & NDR_IN) {
20168         }
20169         if (flags & NDR_OUT) {
20170                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20171         }
20172         return NDR_ERR_SUCCESS;
20173 }
20174
20175 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
20176 {
20177         if (flags & NDR_IN) {
20178         }
20179         if (flags & NDR_OUT) {
20180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20181         }
20182         return NDR_ERR_SUCCESS;
20183 }
20184
20185 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
20186 {
20187         ndr_print_struct(ndr, name, "spoolss_56");
20188         ndr->depth++;
20189         if (flags & NDR_SET_VALUES) {
20190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20191         }
20192         if (flags & NDR_IN) {
20193                 ndr_print_struct(ndr, "in", "spoolss_56");
20194                 ndr->depth++;
20195                 ndr->depth--;
20196         }
20197         if (flags & NDR_OUT) {
20198                 ndr_print_struct(ndr, "out", "spoolss_56");
20199                 ndr->depth++;
20200                 ndr_print_WERROR(ndr, "result", r->out.result);
20201                 ndr->depth--;
20202         }
20203         ndr->depth--;
20204 }
20205
20206 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
20207 {
20208         if (flags & NDR_IN) {
20209         }
20210         if (flags & NDR_OUT) {
20211                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20212         }
20213         return NDR_ERR_SUCCESS;
20214 }
20215
20216 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
20217 {
20218         if (flags & NDR_IN) {
20219         }
20220         if (flags & NDR_OUT) {
20221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20222         }
20223         return NDR_ERR_SUCCESS;
20224 }
20225
20226 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
20227 {
20228         ndr_print_struct(ndr, name, "spoolss_57");
20229         ndr->depth++;
20230         if (flags & NDR_SET_VALUES) {
20231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20232         }
20233         if (flags & NDR_IN) {
20234                 ndr_print_struct(ndr, "in", "spoolss_57");
20235                 ndr->depth++;
20236                 ndr->depth--;
20237         }
20238         if (flags & NDR_OUT) {
20239                 ndr_print_struct(ndr, "out", "spoolss_57");
20240                 ndr->depth++;
20241                 ndr_print_WERROR(ndr, "result", r->out.result);
20242                 ndr->depth--;
20243         }
20244         ndr->depth--;
20245 }
20246
20247 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
20248 {
20249         if (flags & NDR_IN) {
20250                 if (r->in.handle == NULL) {
20251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20252                 }
20253                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
20255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
20257                 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));
20258                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
20259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
20260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
20261                 if (r->in.status_code == NULL) {
20262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20263                 }
20264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
20265         }
20266         if (flags & NDR_OUT) {
20267                 if (r->out.out_data == NULL) {
20268                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20269                 }
20270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
20271                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
20272                 if (r->out.needed == NULL) {
20273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20274                 }
20275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20276                 if (r->out.status_code == NULL) {
20277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20278                 }
20279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
20280                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20281         }
20282         return NDR_ERR_SUCCESS;
20283 }
20284
20285 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
20286 {
20287         TALLOC_CTX *_mem_save_handle_0;
20288         TALLOC_CTX *_mem_save_needed_0;
20289         TALLOC_CTX *_mem_save_status_code_0;
20290         if (flags & NDR_IN) {
20291                 ZERO_STRUCT(r->out);
20292
20293                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20294                         NDR_PULL_ALLOC(ndr, r->in.handle);
20295                 }
20296                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20297                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20298                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20299                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20300                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
20301                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
20302                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
20303                         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));
20304                 }
20305                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
20306                 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));
20307                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
20308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
20309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
20310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20311                         NDR_PULL_ALLOC(ndr, r->in.status_code);
20312                 }
20313                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
20314                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
20315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
20316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
20317                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
20318                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
20319                 NDR_PULL_ALLOC(ndr, r->out.needed);
20320                 ZERO_STRUCTP(r->out.needed);
20321                 NDR_PULL_ALLOC(ndr, r->out.status_code);
20322                 *r->out.status_code = *r->in.status_code;
20323         }
20324         if (flags & NDR_OUT) {
20325                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
20326                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20327                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
20328                 }
20329                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
20330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20331                         NDR_PULL_ALLOC(ndr, r->out.needed);
20332                 }
20333                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20334                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20338                         NDR_PULL_ALLOC(ndr, r->out.status_code);
20339                 }
20340                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
20341                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
20342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
20343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
20344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20345                 if (r->out.out_data) {
20346                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
20347                 }
20348         }
20349         return NDR_ERR_SUCCESS;
20350 }
20351
20352 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
20353 {
20354         ndr_print_struct(ndr, name, "spoolss_XcvData");
20355         ndr->depth++;
20356         if (flags & NDR_SET_VALUES) {
20357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20358         }
20359         if (flags & NDR_IN) {
20360                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
20361                 ndr->depth++;
20362                 ndr_print_ptr(ndr, "handle", r->in.handle);
20363                 ndr->depth++;
20364                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20365                 ndr->depth--;
20366                 ndr_print_string(ndr, "function_name", r->in.function_name);
20367                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
20368                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
20369                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
20370                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
20371                 ndr->depth++;
20372                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
20373                 ndr->depth--;
20374                 ndr->depth--;
20375         }
20376         if (flags & NDR_OUT) {
20377                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
20378                 ndr->depth++;
20379                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
20380                 ndr->depth++;
20381                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
20382                 ndr->depth--;
20383                 ndr_print_ptr(ndr, "needed", r->out.needed);
20384                 ndr->depth++;
20385                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20386                 ndr->depth--;
20387                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
20388                 ndr->depth++;
20389                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
20390                 ndr->depth--;
20391                 ndr_print_WERROR(ndr, "result", r->out.result);
20392                 ndr->depth--;
20393         }
20394         ndr->depth--;
20395 }
20396
20397 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
20398 {
20399         if (flags & NDR_IN) {
20400                 if (r->in.servername == NULL) {
20401                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20402                 }
20403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20406                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20408                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20409                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20410                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
20411         }
20412         if (flags & NDR_OUT) {
20413                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20414         }
20415         return NDR_ERR_SUCCESS;
20416 }
20417
20418 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
20419 {
20420         if (flags & NDR_IN) {
20421                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20422                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20423                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20424                         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));
20425                 }
20426                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20427                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20429                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20430                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20431                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
20432         }
20433         if (flags & NDR_OUT) {
20434                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20435         }
20436         return NDR_ERR_SUCCESS;
20437 }
20438
20439 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
20440 {
20441         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
20442         ndr->depth++;
20443         if (flags & NDR_SET_VALUES) {
20444                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20445         }
20446         if (flags & NDR_IN) {
20447                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
20448                 ndr->depth++;
20449                 ndr_print_ptr(ndr, "servername", r->in.servername);
20450                 ndr->depth++;
20451                 ndr_print_string(ndr, "servername", r->in.servername);
20452                 ndr->depth--;
20453                 ndr_print_uint32(ndr, "level", r->in.level);
20454                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20455                 ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->in.info);
20456                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
20457                 ndr->depth--;
20458         }
20459         if (flags & NDR_OUT) {
20460                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
20461                 ndr->depth++;
20462                 ndr_print_WERROR(ndr, "result", r->out.result);
20463                 ndr->depth--;
20464         }
20465         ndr->depth--;
20466 }
20467
20468 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
20469 {
20470         if (flags & NDR_IN) {
20471         }
20472         if (flags & NDR_OUT) {
20473                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20474         }
20475         return NDR_ERR_SUCCESS;
20476 }
20477
20478 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
20479 {
20480         if (flags & NDR_IN) {
20481         }
20482         if (flags & NDR_OUT) {
20483                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20484         }
20485         return NDR_ERR_SUCCESS;
20486 }
20487
20488 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
20489 {
20490         ndr_print_struct(ndr, name, "spoolss_5a");
20491         ndr->depth++;
20492         if (flags & NDR_SET_VALUES) {
20493                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20494         }
20495         if (flags & NDR_IN) {
20496                 ndr_print_struct(ndr, "in", "spoolss_5a");
20497                 ndr->depth++;
20498                 ndr->depth--;
20499         }
20500         if (flags & NDR_OUT) {
20501                 ndr_print_struct(ndr, "out", "spoolss_5a");
20502                 ndr->depth++;
20503                 ndr_print_WERROR(ndr, "result", r->out.result);
20504                 ndr->depth--;
20505         }
20506         ndr->depth--;
20507 }
20508
20509 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
20510 {
20511         if (flags & NDR_IN) {
20512         }
20513         if (flags & NDR_OUT) {
20514                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20515         }
20516         return NDR_ERR_SUCCESS;
20517 }
20518
20519 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
20520 {
20521         if (flags & NDR_IN) {
20522         }
20523         if (flags & NDR_OUT) {
20524                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20525         }
20526         return NDR_ERR_SUCCESS;
20527 }
20528
20529 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
20530 {
20531         ndr_print_struct(ndr, name, "spoolss_5b");
20532         ndr->depth++;
20533         if (flags & NDR_SET_VALUES) {
20534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20535         }
20536         if (flags & NDR_IN) {
20537                 ndr_print_struct(ndr, "in", "spoolss_5b");
20538                 ndr->depth++;
20539                 ndr->depth--;
20540         }
20541         if (flags & NDR_OUT) {
20542                 ndr_print_struct(ndr, "out", "spoolss_5b");
20543                 ndr->depth++;
20544                 ndr_print_WERROR(ndr, "result", r->out.result);
20545                 ndr->depth--;
20546         }
20547         ndr->depth--;
20548 }
20549
20550 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
20551 {
20552         if (flags & NDR_IN) {
20553         }
20554         if (flags & NDR_OUT) {
20555                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20556         }
20557         return NDR_ERR_SUCCESS;
20558 }
20559
20560 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
20561 {
20562         if (flags & NDR_IN) {
20563         }
20564         if (flags & NDR_OUT) {
20565                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20566         }
20567         return NDR_ERR_SUCCESS;
20568 }
20569
20570 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
20571 {
20572         ndr_print_struct(ndr, name, "spoolss_5c");
20573         ndr->depth++;
20574         if (flags & NDR_SET_VALUES) {
20575                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20576         }
20577         if (flags & NDR_IN) {
20578                 ndr_print_struct(ndr, "in", "spoolss_5c");
20579                 ndr->depth++;
20580                 ndr->depth--;
20581         }
20582         if (flags & NDR_OUT) {
20583                 ndr_print_struct(ndr, "out", "spoolss_5c");
20584                 ndr->depth++;
20585                 ndr_print_WERROR(ndr, "result", r->out.result);
20586                 ndr->depth--;
20587         }
20588         ndr->depth--;
20589 }
20590
20591 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
20592 {
20593         if (flags & NDR_IN) {
20594         }
20595         if (flags & NDR_OUT) {
20596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20597         }
20598         return NDR_ERR_SUCCESS;
20599 }
20600
20601 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
20602 {
20603         if (flags & NDR_IN) {
20604         }
20605         if (flags & NDR_OUT) {
20606                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20607         }
20608         return NDR_ERR_SUCCESS;
20609 }
20610
20611 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
20612 {
20613         ndr_print_struct(ndr, name, "spoolss_5d");
20614         ndr->depth++;
20615         if (flags & NDR_SET_VALUES) {
20616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20617         }
20618         if (flags & NDR_IN) {
20619                 ndr_print_struct(ndr, "in", "spoolss_5d");
20620                 ndr->depth++;
20621                 ndr->depth--;
20622         }
20623         if (flags & NDR_OUT) {
20624                 ndr_print_struct(ndr, "out", "spoolss_5d");
20625                 ndr->depth++;
20626                 ndr_print_WERROR(ndr, "result", r->out.result);
20627                 ndr->depth--;
20628         }
20629         ndr->depth--;
20630 }
20631
20632 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
20633 {
20634         if (flags & NDR_IN) {
20635         }
20636         if (flags & NDR_OUT) {
20637                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20638         }
20639         return NDR_ERR_SUCCESS;
20640 }
20641
20642 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
20643 {
20644         if (flags & NDR_IN) {
20645         }
20646         if (flags & NDR_OUT) {
20647                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20648         }
20649         return NDR_ERR_SUCCESS;
20650 }
20651
20652 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
20653 {
20654         ndr_print_struct(ndr, name, "spoolss_5e");
20655         ndr->depth++;
20656         if (flags & NDR_SET_VALUES) {
20657                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20658         }
20659         if (flags & NDR_IN) {
20660                 ndr_print_struct(ndr, "in", "spoolss_5e");
20661                 ndr->depth++;
20662                 ndr->depth--;
20663         }
20664         if (flags & NDR_OUT) {
20665                 ndr_print_struct(ndr, "out", "spoolss_5e");
20666                 ndr->depth++;
20667                 ndr_print_WERROR(ndr, "result", r->out.result);
20668                 ndr->depth--;
20669         }
20670         ndr->depth--;
20671 }
20672
20673 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
20674 {
20675         if (flags & NDR_IN) {
20676         }
20677         if (flags & NDR_OUT) {
20678                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20679         }
20680         return NDR_ERR_SUCCESS;
20681 }
20682
20683 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
20684 {
20685         if (flags & NDR_IN) {
20686         }
20687         if (flags & NDR_OUT) {
20688                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20689         }
20690         return NDR_ERR_SUCCESS;
20691 }
20692
20693 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
20694 {
20695         ndr_print_struct(ndr, name, "spoolss_5f");
20696         ndr->depth++;
20697         if (flags & NDR_SET_VALUES) {
20698                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20699         }
20700         if (flags & NDR_IN) {
20701                 ndr_print_struct(ndr, "in", "spoolss_5f");
20702                 ndr->depth++;
20703                 ndr->depth--;
20704         }
20705         if (flags & NDR_OUT) {
20706                 ndr_print_struct(ndr, "out", "spoolss_5f");
20707                 ndr->depth++;
20708                 ndr_print_WERROR(ndr, "result", r->out.result);
20709                 ndr->depth--;
20710         }
20711         ndr->depth--;
20712 }
20713
20714 static const struct ndr_interface_call spoolss_calls[] = {
20715         {
20716                 "spoolss_EnumPrinters",
20717                 sizeof(struct spoolss_EnumPrinters),
20718                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
20719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
20720                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
20721                 false,
20722         },
20723         {
20724                 "spoolss_OpenPrinter",
20725                 sizeof(struct spoolss_OpenPrinter),
20726                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
20727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
20728                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
20729                 false,
20730         },
20731         {
20732                 "spoolss_SetJob",
20733                 sizeof(struct spoolss_SetJob),
20734                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
20735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
20736                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
20737                 false,
20738         },
20739         {
20740                 "spoolss_GetJob",
20741                 sizeof(struct spoolss_GetJob),
20742                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
20743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
20744                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
20745                 false,
20746         },
20747         {
20748                 "spoolss_EnumJobs",
20749                 sizeof(struct spoolss_EnumJobs),
20750                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
20751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
20752                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
20753                 false,
20754         },
20755         {
20756                 "spoolss_AddPrinter",
20757                 sizeof(struct spoolss_AddPrinter),
20758                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
20759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
20760                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
20761                 false,
20762         },
20763         {
20764                 "spoolss_DeletePrinter",
20765                 sizeof(struct spoolss_DeletePrinter),
20766                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
20767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
20768                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
20769                 false,
20770         },
20771         {
20772                 "spoolss_SetPrinter",
20773                 sizeof(struct spoolss_SetPrinter),
20774                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
20775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
20776                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
20777                 false,
20778         },
20779         {
20780                 "spoolss_GetPrinter",
20781                 sizeof(struct spoolss_GetPrinter),
20782                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
20783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
20784                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
20785                 false,
20786         },
20787         {
20788                 "spoolss_AddPrinterDriver",
20789                 sizeof(struct spoolss_AddPrinterDriver),
20790                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
20791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
20792                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
20793                 false,
20794         },
20795         {
20796                 "spoolss_EnumPrinterDrivers",
20797                 sizeof(struct spoolss_EnumPrinterDrivers),
20798                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
20799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
20800                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
20801                 false,
20802         },
20803         {
20804                 "spoolss_GetPrinterDriver",
20805                 sizeof(struct spoolss_GetPrinterDriver),
20806                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
20807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
20808                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
20809                 false,
20810         },
20811         {
20812                 "spoolss_GetPrinterDriverDirectory",
20813                 sizeof(struct spoolss_GetPrinterDriverDirectory),
20814                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
20815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
20816                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
20817                 false,
20818         },
20819         {
20820                 "spoolss_DeletePrinterDriver",
20821                 sizeof(struct spoolss_DeletePrinterDriver),
20822                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
20823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
20824                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
20825                 false,
20826         },
20827         {
20828                 "spoolss_AddPrintProcessor",
20829                 sizeof(struct spoolss_AddPrintProcessor),
20830                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
20831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
20832                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
20833                 false,
20834         },
20835         {
20836                 "spoolss_EnumPrintProcessors",
20837                 sizeof(struct spoolss_EnumPrintProcessors),
20838                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
20839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
20840                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
20841                 false,
20842         },
20843         {
20844                 "spoolss_GetPrintProcessorDirectory",
20845                 sizeof(struct spoolss_GetPrintProcessorDirectory),
20846                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
20847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
20848                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
20849                 false,
20850         },
20851         {
20852                 "spoolss_StartDocPrinter",
20853                 sizeof(struct spoolss_StartDocPrinter),
20854                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
20855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
20856                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
20857                 false,
20858         },
20859         {
20860                 "spoolss_StartPagePrinter",
20861                 sizeof(struct spoolss_StartPagePrinter),
20862                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
20863                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
20864                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
20865                 false,
20866         },
20867         {
20868                 "spoolss_WritePrinter",
20869                 sizeof(struct spoolss_WritePrinter),
20870                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
20871                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
20872                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
20873                 false,
20874         },
20875         {
20876                 "spoolss_EndPagePrinter",
20877                 sizeof(struct spoolss_EndPagePrinter),
20878                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
20879                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
20880                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
20881                 false,
20882         },
20883         {
20884                 "spoolss_AbortPrinter",
20885                 sizeof(struct spoolss_AbortPrinter),
20886                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
20887                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
20888                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
20889                 false,
20890         },
20891         {
20892                 "spoolss_ReadPrinter",
20893                 sizeof(struct spoolss_ReadPrinter),
20894                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
20895                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
20896                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
20897                 false,
20898         },
20899         {
20900                 "spoolss_EndDocPrinter",
20901                 sizeof(struct spoolss_EndDocPrinter),
20902                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
20903                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
20904                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
20905                 false,
20906         },
20907         {
20908                 "spoolss_AddJob",
20909                 sizeof(struct spoolss_AddJob),
20910                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
20911                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
20912                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
20913                 false,
20914         },
20915         {
20916                 "spoolss_ScheduleJob",
20917                 sizeof(struct spoolss_ScheduleJob),
20918                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
20919                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
20920                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
20921                 false,
20922         },
20923         {
20924                 "spoolss_GetPrinterData",
20925                 sizeof(struct spoolss_GetPrinterData),
20926                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
20927                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
20928                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
20929                 false,
20930         },
20931         {
20932                 "spoolss_SetPrinterData",
20933                 sizeof(struct spoolss_SetPrinterData),
20934                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
20935                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
20936                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
20937                 false,
20938         },
20939         {
20940                 "spoolss_WaitForPrinterChange",
20941                 sizeof(struct spoolss_WaitForPrinterChange),
20942                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
20943                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
20944                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
20945                 false,
20946         },
20947         {
20948                 "spoolss_ClosePrinter",
20949                 sizeof(struct spoolss_ClosePrinter),
20950                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
20951                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
20952                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
20953                 false,
20954         },
20955         {
20956                 "spoolss_AddForm",
20957                 sizeof(struct spoolss_AddForm),
20958                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
20959                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
20960                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
20961                 false,
20962         },
20963         {
20964                 "spoolss_DeleteForm",
20965                 sizeof(struct spoolss_DeleteForm),
20966                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
20967                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
20968                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
20969                 false,
20970         },
20971         {
20972                 "spoolss_GetForm",
20973                 sizeof(struct spoolss_GetForm),
20974                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
20975                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
20976                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
20977                 false,
20978         },
20979         {
20980                 "spoolss_SetForm",
20981                 sizeof(struct spoolss_SetForm),
20982                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
20983                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
20984                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
20985                 false,
20986         },
20987         {
20988                 "spoolss_EnumForms",
20989                 sizeof(struct spoolss_EnumForms),
20990                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
20991                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
20992                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
20993                 false,
20994         },
20995         {
20996                 "spoolss_EnumPorts",
20997                 sizeof(struct spoolss_EnumPorts),
20998                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
20999                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
21000                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
21001                 false,
21002         },
21003         {
21004                 "spoolss_EnumMonitors",
21005                 sizeof(struct spoolss_EnumMonitors),
21006                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
21007                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
21008                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
21009                 false,
21010         },
21011         {
21012                 "spoolss_AddPort",
21013                 sizeof(struct spoolss_AddPort),
21014                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
21015                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
21016                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
21017                 false,
21018         },
21019         {
21020                 "spoolss_ConfigurePort",
21021                 sizeof(struct spoolss_ConfigurePort),
21022                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
21023                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
21024                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
21025                 false,
21026         },
21027         {
21028                 "spoolss_DeletePort",
21029                 sizeof(struct spoolss_DeletePort),
21030                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
21031                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
21032                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
21033                 false,
21034         },
21035         {
21036                 "spoolss_CreatePrinterIC",
21037                 sizeof(struct spoolss_CreatePrinterIC),
21038                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
21039                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
21040                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
21041                 false,
21042         },
21043         {
21044                 "spoolss_PlayGDIScriptOnPrinterIC",
21045                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
21046                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
21047                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
21048                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
21049                 false,
21050         },
21051         {
21052                 "spoolss_DeletePrinterIC",
21053                 sizeof(struct spoolss_DeletePrinterIC),
21054                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
21055                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
21056                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
21057                 false,
21058         },
21059         {
21060                 "spoolss_AddPrinterConnection",
21061                 sizeof(struct spoolss_AddPrinterConnection),
21062                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
21063                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
21064                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
21065                 false,
21066         },
21067         {
21068                 "spoolss_DeletePrinterConnection",
21069                 sizeof(struct spoolss_DeletePrinterConnection),
21070                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
21071                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
21072                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
21073                 false,
21074         },
21075         {
21076                 "spoolss_PrinterMessageBox",
21077                 sizeof(struct spoolss_PrinterMessageBox),
21078                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
21079                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
21080                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
21081                 false,
21082         },
21083         {
21084                 "spoolss_AddMonitor",
21085                 sizeof(struct spoolss_AddMonitor),
21086                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
21087                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
21088                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
21089                 false,
21090         },
21091         {
21092                 "spoolss_DeleteMonitor",
21093                 sizeof(struct spoolss_DeleteMonitor),
21094                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
21095                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
21096                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
21097                 false,
21098         },
21099         {
21100                 "spoolss_DeletePrintProcessor",
21101                 sizeof(struct spoolss_DeletePrintProcessor),
21102                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
21103                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
21104                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
21105                 false,
21106         },
21107         {
21108                 "spoolss_AddPrintProvidor",
21109                 sizeof(struct spoolss_AddPrintProvidor),
21110                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
21111                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
21112                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
21113                 false,
21114         },
21115         {
21116                 "spoolss_DeletePrintProvidor",
21117                 sizeof(struct spoolss_DeletePrintProvidor),
21118                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
21119                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
21120                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
21121                 false,
21122         },
21123         {
21124                 "spoolss_EnumPrintProcDataTypes",
21125                 sizeof(struct spoolss_EnumPrintProcDataTypes),
21126                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
21127                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
21128                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
21129                 false,
21130         },
21131         {
21132                 "spoolss_ResetPrinter",
21133                 sizeof(struct spoolss_ResetPrinter),
21134                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
21135                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
21136                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
21137                 false,
21138         },
21139         {
21140                 "spoolss_GetPrinterDriver2",
21141                 sizeof(struct spoolss_GetPrinterDriver2),
21142                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
21143                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
21144                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
21145                 false,
21146         },
21147         {
21148                 "spoolss_FindFirstPrinterChangeNotification",
21149                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
21150                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
21151                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
21152                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
21153                 false,
21154         },
21155         {
21156                 "spoolss_FindNextPrinterChangeNotification",
21157                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
21158                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
21159                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
21160                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
21161                 false,
21162         },
21163         {
21164                 "spoolss_FindClosePrinterNotify",
21165                 sizeof(struct spoolss_FindClosePrinterNotify),
21166                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
21167                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
21168                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
21169                 false,
21170         },
21171         {
21172                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
21173                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
21174                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
21175                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
21176                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
21177                 false,
21178         },
21179         {
21180                 "spoolss_ReplyOpenPrinter",
21181                 sizeof(struct spoolss_ReplyOpenPrinter),
21182                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
21183                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
21184                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
21185                 false,
21186         },
21187         {
21188                 "spoolss_RouterReplyPrinter",
21189                 sizeof(struct spoolss_RouterReplyPrinter),
21190                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
21191                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
21192                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
21193                 false,
21194         },
21195         {
21196                 "spoolss_ReplyClosePrinter",
21197                 sizeof(struct spoolss_ReplyClosePrinter),
21198                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
21199                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
21200                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
21201                 false,
21202         },
21203         {
21204                 "spoolss_AddPortEx",
21205                 sizeof(struct spoolss_AddPortEx),
21206                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
21207                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
21208                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
21209                 false,
21210         },
21211         {
21212                 "spoolss_RouterFindFirstPrinterChangeNotification",
21213                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
21214                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
21215                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
21216                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
21217                 false,
21218         },
21219         {
21220                 "spoolss_SpoolerInit",
21221                 sizeof(struct spoolss_SpoolerInit),
21222                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
21223                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
21224                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
21225                 false,
21226         },
21227         {
21228                 "spoolss_ResetPrinterEx",
21229                 sizeof(struct spoolss_ResetPrinterEx),
21230                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
21231                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
21232                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
21233                 false,
21234         },
21235         {
21236                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
21237                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
21238                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
21239                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
21240                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
21241                 false,
21242         },
21243         {
21244                 "spoolss_RouterReplyPrinterEx",
21245                 sizeof(struct spoolss_RouterReplyPrinterEx),
21246                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
21247                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
21248                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
21249                 false,
21250         },
21251         {
21252                 "spoolss_RouterRefreshPrinterChangeNotify",
21253                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
21254                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
21255                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
21256                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
21257                 false,
21258         },
21259         {
21260                 "spoolss_44",
21261                 sizeof(struct spoolss_44),
21262                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
21263                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
21264                 (ndr_print_function_t) ndr_print_spoolss_44,
21265                 false,
21266         },
21267         {
21268                 "spoolss_OpenPrinterEx",
21269                 sizeof(struct spoolss_OpenPrinterEx),
21270                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
21271                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
21272                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
21273                 false,
21274         },
21275         {
21276                 "spoolss_AddPrinterEx",
21277                 sizeof(struct spoolss_AddPrinterEx),
21278                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
21279                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
21280                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
21281                 false,
21282         },
21283         {
21284                 "spoolss_47",
21285                 sizeof(struct spoolss_47),
21286                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
21287                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
21288                 (ndr_print_function_t) ndr_print_spoolss_47,
21289                 false,
21290         },
21291         {
21292                 "spoolss_EnumPrinterData",
21293                 sizeof(struct spoolss_EnumPrinterData),
21294                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
21295                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
21296                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
21297                 false,
21298         },
21299         {
21300                 "spoolss_DeletePrinterData",
21301                 sizeof(struct spoolss_DeletePrinterData),
21302                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
21303                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
21304                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
21305                 false,
21306         },
21307         {
21308                 "spoolss_4a",
21309                 sizeof(struct spoolss_4a),
21310                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
21311                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
21312                 (ndr_print_function_t) ndr_print_spoolss_4a,
21313                 false,
21314         },
21315         {
21316                 "spoolss_4b",
21317                 sizeof(struct spoolss_4b),
21318                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
21319                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
21320                 (ndr_print_function_t) ndr_print_spoolss_4b,
21321                 false,
21322         },
21323         {
21324                 "spoolss_4c",
21325                 sizeof(struct spoolss_4c),
21326                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
21327                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
21328                 (ndr_print_function_t) ndr_print_spoolss_4c,
21329                 false,
21330         },
21331         {
21332                 "spoolss_SetPrinterDataEx",
21333                 sizeof(struct spoolss_SetPrinterDataEx),
21334                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
21335                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
21336                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
21337                 false,
21338         },
21339         {
21340                 "spoolss_GetPrinterDataEx",
21341                 sizeof(struct spoolss_GetPrinterDataEx),
21342                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
21343                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
21344                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
21345                 false,
21346         },
21347         {
21348                 "spoolss_EnumPrinterDataEx",
21349                 sizeof(struct spoolss_EnumPrinterDataEx),
21350                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
21351                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
21352                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
21353                 false,
21354         },
21355         {
21356                 "spoolss_EnumPrinterKey",
21357                 sizeof(struct spoolss_EnumPrinterKey),
21358                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
21359                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
21360                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
21361                 false,
21362         },
21363         {
21364                 "spoolss_DeletePrinterDataEx",
21365                 sizeof(struct spoolss_DeletePrinterDataEx),
21366                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
21367                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
21368                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
21369                 false,
21370         },
21371         {
21372                 "spoolss_DeletePrinterKey",
21373                 sizeof(struct spoolss_DeletePrinterKey),
21374                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
21375                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
21376                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
21377                 false,
21378         },
21379         {
21380                 "spoolss_53",
21381                 sizeof(struct spoolss_53),
21382                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
21383                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
21384                 (ndr_print_function_t) ndr_print_spoolss_53,
21385                 false,
21386         },
21387         {
21388                 "spoolss_DeletePrinterDriverEx",
21389                 sizeof(struct spoolss_DeletePrinterDriverEx),
21390                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
21391                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
21392                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
21393                 false,
21394         },
21395         {
21396                 "spoolss_55",
21397                 sizeof(struct spoolss_55),
21398                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
21399                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
21400                 (ndr_print_function_t) ndr_print_spoolss_55,
21401                 false,
21402         },
21403         {
21404                 "spoolss_56",
21405                 sizeof(struct spoolss_56),
21406                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
21407                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
21408                 (ndr_print_function_t) ndr_print_spoolss_56,
21409                 false,
21410         },
21411         {
21412                 "spoolss_57",
21413                 sizeof(struct spoolss_57),
21414                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
21415                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
21416                 (ndr_print_function_t) ndr_print_spoolss_57,
21417                 false,
21418         },
21419         {
21420                 "spoolss_XcvData",
21421                 sizeof(struct spoolss_XcvData),
21422                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
21423                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
21424                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
21425                 false,
21426         },
21427         {
21428                 "spoolss_AddPrinterDriverEx",
21429                 sizeof(struct spoolss_AddPrinterDriverEx),
21430                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
21431                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
21432                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
21433                 false,
21434         },
21435         {
21436                 "spoolss_5a",
21437                 sizeof(struct spoolss_5a),
21438                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
21439                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
21440                 (ndr_print_function_t) ndr_print_spoolss_5a,
21441                 false,
21442         },
21443         {
21444                 "spoolss_5b",
21445                 sizeof(struct spoolss_5b),
21446                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
21447                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
21448                 (ndr_print_function_t) ndr_print_spoolss_5b,
21449                 false,
21450         },
21451         {
21452                 "spoolss_5c",
21453                 sizeof(struct spoolss_5c),
21454                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
21455                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
21456                 (ndr_print_function_t) ndr_print_spoolss_5c,
21457                 false,
21458         },
21459         {
21460                 "spoolss_5d",
21461                 sizeof(struct spoolss_5d),
21462                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
21463                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
21464                 (ndr_print_function_t) ndr_print_spoolss_5d,
21465                 false,
21466         },
21467         {
21468                 "spoolss_5e",
21469                 sizeof(struct spoolss_5e),
21470                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
21471                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
21472                 (ndr_print_function_t) ndr_print_spoolss_5e,
21473                 false,
21474         },
21475         {
21476                 "spoolss_5f",
21477                 sizeof(struct spoolss_5f),
21478                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
21479                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
21480                 (ndr_print_function_t) ndr_print_spoolss_5f,
21481                 false,
21482         },
21483         { NULL, 0, NULL, NULL, NULL, false }
21484 };
21485
21486 static const char * const spoolss_endpoint_strings[] = {
21487         "ncacn_np:[\\pipe\\spoolss]",
21488 };
21489
21490 static const struct ndr_interface_string_array spoolss_endpoints = {
21491         .count  = 1,
21492         .names  = spoolss_endpoint_strings
21493 };
21494
21495 static const char * const spoolss_authservice_strings[] = {
21496         "host",
21497 };
21498
21499 static const struct ndr_interface_string_array spoolss_authservices = {
21500         .count  = 1,
21501         .names  = spoolss_authservice_strings
21502 };
21503
21504
21505 const struct ndr_interface_table ndr_table_spoolss = {
21506         .name           = "spoolss",
21507         .syntax_id      = {
21508                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
21509                 NDR_SPOOLSS_VERSION
21510         },
21511         .helpstring     = NDR_SPOOLSS_HELPSTRING,
21512         .num_calls      = 114,
21513         .calls          = spoolss_calls,
21514         .endpoints      = &spoolss_endpoints,
21515         .authservices   = &spoolss_authservices
21516 };
21517