librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 228 {
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_push_align(ndr, 4));
 231                 {
 232                         uint32_t _flags_save_string = ndr->flags;
 233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 235                         ndr->flags = _flags_save_string;
 236                 }
 237                 {
 238                         uint32_t _flags_save_string = ndr->flags;
 239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 241                         ndr->flags = _flags_save_string;
 242                 }
 243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 246                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
 257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 258                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 265                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 270         }
 271         if (ndr_flags & NDR_BUFFERS) {
 272                 {
 273                         uint32_t _flags_save_string = ndr->flags;
 274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 275                         if (r->printername) {
 276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 278                         }
 279                         ndr->flags = _flags_save_string;
 280                 }
 281                 {
 282                         uint32_t _flags_save_string = ndr->flags;
 283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 284                         if (r->servername) {
 285                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 286                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 287                         }
 288                         ndr->flags = _flags_save_string;
 289                 }
 290         }
 291         return NDR_ERR_SUCCESS;
 292 }
 293
 294 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 295 {
 296         uint32_t _ptr_printername;
 297         TALLOC_CTX *_mem_save_printername_0;
 298         uint32_t _ptr_servername;
 299         TALLOC_CTX *_mem_save_servername_0;
 300         if (ndr_flags & NDR_SCALARS) {
 301                 NDR_CHECK(ndr_pull_align(ndr, 4));
 302                 {
 303                         uint32_t _flags_save_string = ndr->flags;
 304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 306                         if (_ptr_printername) {
 307                                 NDR_PULL_ALLOC(ndr, r->printername);
 308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 309                         } else {
 310                                 r->printername = NULL;
 311                         }
 312                         ndr->flags = _flags_save_string;
 313                 }
 314                 {
 315                         uint32_t _flags_save_string = ndr->flags;
 316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 318                         if (_ptr_servername) {
 319                                 NDR_PULL_ALLOC(ndr, r->servername);
 320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 321                         } else {
 322                                 r->servername = NULL;
 323                         }
 324                         ndr->flags = _flags_save_string;
 325                 }
 326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 329                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
 340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 341                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 348                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 349                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 353         }
 354         if (ndr_flags & NDR_BUFFERS) {
 355                 {
 356                         uint32_t _flags_save_string = ndr->flags;
 357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 358                         if (r->printername) {
 359                                 uint32_t _relative_save_offset;
 360                                 _relative_save_offset = ndr->offset;
 361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 362                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 363                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 366                                 ndr->offset = _relative_save_offset;
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370                 {
 371                         uint32_t _flags_save_string = ndr->flags;
 372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 373                         if (r->servername) {
 374                                 uint32_t _relative_save_offset;
 375                                 _relative_save_offset = ndr->offset;
 376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 377                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 378                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 379                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 381                                 ndr->offset = _relative_save_offset;
 382                         }
 383                         ndr->flags = _flags_save_string;
 384                 }
 385         }
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 390 {
 391         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 392         ndr->depth++;
 393         ndr_print_ptr(ndr, "printername", r->printername);
 394         ndr->depth++;
 395         if (r->printername) {
 396                 ndr_print_string(ndr, "printername", r->printername);
 397         }
 398         ndr->depth--;
 399         ndr_print_ptr(ndr, "servername", r->servername);
 400         ndr->depth++;
 401         if (r->servername) {
 402                 ndr_print_string(ndr, "servername", r->servername);
 403         }
 404         ndr->depth--;
 405         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 406         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 407         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 408         ndr_print_spoolss_Time(ndr, "time", &r->time);
 409         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 410         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 411         ndr_print_uint32(ndr, "version", r->version);
 412         ndr_print_uint32(ndr, "free_build", r->free_build);
 413         ndr_print_uint32(ndr, "spooling", r->spooling);
 414         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 415         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 416         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 417         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 418         ndr_print_uint32(ndr, "job_error", r->job_error);
 419         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 420         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 421         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 422         ndr_print_uint32(ndr, "change_id", r->change_id);
 423         ndr_print_WERROR(ndr, "last_error", r->last_error);
 424         ndr_print_uint32(ndr, "status", r->status);
 425         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 426         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 427         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 428         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 429         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 430         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 431         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 432         ndr->depth--;
 433 }
 434
 435 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 436 {
 437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 438         return NDR_ERR_SUCCESS;
 439 }
 440
 441 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 442 {
 443         uint32_t v;
 444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 445         *r = v;
 446         return NDR_ERR_SUCCESS;
 447 }
 448
 449 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 450 {
 451         ndr_print_uint32(ndr, name, r);
 452         ndr->depth++;
 453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 464         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 465         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 466         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 467         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 468         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 469         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 470         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 474         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 478         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 480         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 481         ndr->depth--;
 482 }
 483
 484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 485 {
 486         if (ndr_flags & NDR_SCALARS) {
 487                 NDR_CHECK(ndr_push_align(ndr, 4));
 488                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 489                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 490                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 491                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 492                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 493                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 494                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 496                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 497                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 498                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 499                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 500                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 501                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 502                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 503                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 504                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 505                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 506                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 507                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 508                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 522                 {
 523                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 525                         {
 526                                 struct ndr_push *_ndr_driverextra_data;
 527                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 528                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 529                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 530                         }
 531                         ndr->flags = _flags_save_DATA_BLOB;
 532                 }
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535         }
 536         return NDR_ERR_SUCCESS;
 537 }
 538
 539 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 540 {
 541         if (ndr_flags & NDR_SCALARS) {
 542                 NDR_CHECK(ndr_pull_align(ndr, 4));
 543                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 544                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 545                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 546                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 547                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 548                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 549                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 550                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 551                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 552                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 553                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 554                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 555                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 556                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 557                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 558                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 559                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 560                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 562                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 563                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 577                 {
 578                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 580                         {
 581                                 struct ndr_pull *_ndr_driverextra_data;
 582                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 583                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 584                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 585                         }
 586                         ndr->flags = _flags_save_DATA_BLOB;
 587                 }
 588         }
 589         if (ndr_flags & NDR_BUFFERS) {
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 595 {
 596         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 597         ndr->depth++;
 598         ndr_print_string(ndr, "devicename", r->devicename);
 599         ndr_print_uint16(ndr, "specversion", r->specversion);
 600         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 601         ndr_print_uint16(ndr, "size", r->size);
 602         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 603         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 604         ndr_print_uint16(ndr, "orientation", r->orientation);
 605         ndr_print_uint16(ndr, "papersize", r->papersize);
 606         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 607         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 608         ndr_print_uint16(ndr, "scale", r->scale);
 609         ndr_print_uint16(ndr, "copies", r->copies);
 610         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 611         ndr_print_uint16(ndr, "printquality", r->printquality);
 612         ndr_print_uint16(ndr, "color", r->color);
 613         ndr_print_uint16(ndr, "duplex", r->duplex);
 614         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 615         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 616         ndr_print_uint16(ndr, "collate", r->collate);
 617         ndr_print_string(ndr, "formname", r->formname);
 618         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 619         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 620         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 621         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 622         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 623         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 624         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 625         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 626         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 627         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 628         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 629         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 630         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 631         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 632         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 633         ndr->depth--;
 634 }
 635
 636 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 637 {
 638         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 639 }
 640
 641 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 642 {
 643         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 644         return NDR_ERR_SUCCESS;
 645 }
 646
 647 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 648 {
 649         uint32_t v;
 650         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 651         *r = v;
 652         return NDR_ERR_SUCCESS;
 653 }
 654
 655 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 656 {
 657         ndr_print_uint32(ndr, name, r);
 658         ndr->depth++;
 659         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 660         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 678         ndr->depth--;
 679 }
 680
 681 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 682 {
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_push_align(ndr, 4));
 685                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 686                 {
 687                         uint32_t _flags_save_string = ndr->flags;
 688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 689                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 690                         ndr->flags = _flags_save_string;
 691                 }
 692                 {
 693                         uint32_t _flags_save_string = ndr->flags;
 694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 695                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 696                         ndr->flags = _flags_save_string;
 697                 }
 698                 {
 699                         uint32_t _flags_save_string = ndr->flags;
 700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 701                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 702                         ndr->flags = _flags_save_string;
 703                 }
 704         }
 705         if (ndr_flags & NDR_BUFFERS) {
 706                 {
 707                         uint32_t _flags_save_string = ndr->flags;
 708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 709                         if (r->name) {
 710                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 712                         }
 713                         ndr->flags = _flags_save_string;
 714                 }
 715                 {
 716                         uint32_t _flags_save_string = ndr->flags;
 717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 718                         if (r->description) {
 719                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 720                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 721                         }
 722                         ndr->flags = _flags_save_string;
 723                 }
 724                 {
 725                         uint32_t _flags_save_string = ndr->flags;
 726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 727                         if (r->comment) {
 728                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 730                         }
 731                         ndr->flags = _flags_save_string;
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 738 {
 739         uint32_t _ptr_name;
 740         TALLOC_CTX *_mem_save_name_0;
 741         uint32_t _ptr_description;
 742         TALLOC_CTX *_mem_save_description_0;
 743         uint32_t _ptr_comment;
 744         TALLOC_CTX *_mem_save_comment_0;
 745         if (ndr_flags & NDR_SCALARS) {
 746                 NDR_CHECK(ndr_pull_align(ndr, 4));
 747                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 748                 {
 749                         uint32_t _flags_save_string = ndr->flags;
 750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 752                         if (_ptr_name) {
 753                                 NDR_PULL_ALLOC(ndr, r->name);
 754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 755                         } else {
 756                                 r->name = NULL;
 757                         }
 758                         ndr->flags = _flags_save_string;
 759                 }
 760                 {
 761                         uint32_t _flags_save_string = ndr->flags;
 762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 764                         if (_ptr_description) {
 765                                 NDR_PULL_ALLOC(ndr, r->description);
 766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 767                         } else {
 768                                 r->description = NULL;
 769                         }
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 776                         if (_ptr_comment) {
 777                                 NDR_PULL_ALLOC(ndr, r->comment);
 778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 779                         } else {
 780                                 r->comment = NULL;
 781                         }
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 uint32_t _relative_save_offset;
 791                                 _relative_save_offset = ndr->offset;
 792                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 793                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 795                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 796                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 797                                 ndr->offset = _relative_save_offset;
 798                         }
 799                         ndr->flags = _flags_save_string;
 800                 }
 801                 {
 802                         uint32_t _flags_save_string = ndr->flags;
 803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 804                         if (r->description) {
 805                                 uint32_t _relative_save_offset;
 806                                 _relative_save_offset = ndr->offset;
 807                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 808                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 809                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 810                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 811                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 812                                 ndr->offset = _relative_save_offset;
 813                         }
 814                         ndr->flags = _flags_save_string;
 815                 }
 816                 {
 817                         uint32_t _flags_save_string = ndr->flags;
 818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 819                         if (r->comment) {
 820                                 uint32_t _relative_save_offset;
 821                                 _relative_save_offset = ndr->offset;
 822                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 823                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 824                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 825                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 827                                 ndr->offset = _relative_save_offset;
 828                         }
 829                         ndr->flags = _flags_save_string;
 830                 }
 831         }
 832         return NDR_ERR_SUCCESS;
 833 }
 834
 835 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 836 {
 837         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 838         ndr->depth++;
 839         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 840         ndr_print_ptr(ndr, "name", r->name);
 841         ndr->depth++;
 842         if (r->name) {
 843                 ndr_print_string(ndr, "name", r->name);
 844         }
 845         ndr->depth--;
 846         ndr_print_ptr(ndr, "description", r->description);
 847         ndr->depth++;
 848         if (r->description) {
 849                 ndr_print_string(ndr, "description", r->description);
 850         }
 851         ndr->depth--;
 852         ndr_print_ptr(ndr, "comment", r->comment);
 853         ndr->depth++;
 854         if (r->comment) {
 855                 ndr_print_string(ndr, "comment", r->comment);
 856         }
 857         ndr->depth--;
 858         ndr->depth--;
 859 }
 860
 861 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 862 {
 863         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 868 {
 869         uint32_t v;
 870         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 871         *r = v;
 872         return NDR_ERR_SUCCESS;
 873 }
 874
 875 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 876 {
 877         ndr_print_uint32(ndr, name, r);
 878         ndr->depth++;
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 889         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 890         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 891         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 893         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 895         ndr->depth--;
 896 }
 897
 898 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 899 {
 900         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 901         return NDR_ERR_SUCCESS;
 902 }
 903
 904 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 905 {
 906         uint32_t v;
 907         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 908         *r = v;
 909         return NDR_ERR_SUCCESS;
 910 }
 911
 912 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 913 {
 914         ndr_print_uint32(ndr, name, r);
 915         ndr->depth++;
 916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 941         ndr->depth--;
 942 }
 943
 944 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 945 {
 946         if (ndr_flags & NDR_SCALARS) {
 947                 NDR_CHECK(ndr_push_align(ndr, 4));
 948                 {
 949                         uint32_t _flags_save_string = ndr->flags;
 950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 951                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 952                         ndr->flags = _flags_save_string;
 953                 }
 954                 {
 955                         uint32_t _flags_save_string = ndr->flags;
 956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 958                         ndr->flags = _flags_save_string;
 959                 }
 960                 {
 961                         uint32_t _flags_save_string = ndr->flags;
 962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 964                         ndr->flags = _flags_save_string;
 965                 }
 966                 {
 967                         uint32_t _flags_save_string = ndr->flags;
 968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
 970                         ndr->flags = _flags_save_string;
 971                 }
 972                 {
 973                         uint32_t _flags_save_string = ndr->flags;
 974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
 976                         ndr->flags = _flags_save_string;
 977                 }
 978                 {
 979                         uint32_t _flags_save_string = ndr->flags;
 980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 982                         ndr->flags = _flags_save_string;
 983                 }
 984                 {
 985                         uint32_t _flags_save_string = ndr->flags;
 986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
 988                         ndr->flags = _flags_save_string;
 989                 }
 990                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
 991                 {
 992                         uint32_t _flags_save_string = ndr->flags;
 993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 994                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
 995                         ndr->flags = _flags_save_string;
 996                 }
 997                 {
 998                         uint32_t _flags_save_string = ndr->flags;
 999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1000                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1001                         ndr->flags = _flags_save_string;
1002                 }
1003                 {
1004                         uint32_t _flags_save_string = ndr->flags;
1005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1007                         ndr->flags = _flags_save_string;
1008                 }
1009                 {
1010                         uint32_t _flags_save_string = ndr->flags;
1011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1013                         ndr->flags = _flags_save_string;
1014                 }
1015                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1016                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1021                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1024         }
1025         if (ndr_flags & NDR_BUFFERS) {
1026                 {
1027                         uint32_t _flags_save_string = ndr->flags;
1028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1029                         if (r->servername) {
1030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1032                         }
1033                         ndr->flags = _flags_save_string;
1034                 }
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         if (r->printername) {
1039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1041                         }
1042                         ndr->flags = _flags_save_string;
1043                 }
1044                 {
1045                         uint32_t _flags_save_string = ndr->flags;
1046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1047                         if (r->sharename) {
1048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1050                         }
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         if (r->portname) {
1057                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1058                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1059                         }
1060                         ndr->flags = _flags_save_string;
1061                 }
1062                 {
1063                         uint32_t _flags_save_string = ndr->flags;
1064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1065                         if (r->drivername) {
1066                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1067                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1068                         }
1069                         ndr->flags = _flags_save_string;
1070                 }
1071                 {
1072                         uint32_t _flags_save_string = ndr->flags;
1073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1074                         if (r->comment) {
1075                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1076                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1077                         }
1078                         ndr->flags = _flags_save_string;
1079                 }
1080                 {
1081                         uint32_t _flags_save_string = ndr->flags;
1082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1083                         if (r->location) {
1084                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1085                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1086                         }
1087                         ndr->flags = _flags_save_string;
1088                 }
1089                 if (r->devmode) {
1090                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1091                         {
1092                                 struct ndr_push *_ndr_devmode;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1094                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1096                         }
1097                 }
1098                 {
1099                         uint32_t _flags_save_string = ndr->flags;
1100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1101                         if (r->sepfile) {
1102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1104                         }
1105                         ndr->flags = _flags_save_string;
1106                 }
1107                 {
1108                         uint32_t _flags_save_string = ndr->flags;
1109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1110                         if (r->printprocessor) {
1111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1113                         }
1114                         ndr->flags = _flags_save_string;
1115                 }
1116                 {
1117                         uint32_t _flags_save_string = ndr->flags;
1118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1119                         if (r->datatype) {
1120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1122                         }
1123                         ndr->flags = _flags_save_string;
1124                 }
1125                 {
1126                         uint32_t _flags_save_string = ndr->flags;
1127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1128                         if (r->parameters) {
1129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1131                         }
1132                         ndr->flags = _flags_save_string;
1133                 }
1134                 if (r->secdesc) {
1135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1136                         {
1137                                 struct ndr_push *_ndr_secdesc;
1138                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1139                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1140                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1141                         }
1142                 }
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1148 {
1149         uint32_t _ptr_servername;
1150         TALLOC_CTX *_mem_save_servername_0;
1151         uint32_t _ptr_printername;
1152         TALLOC_CTX *_mem_save_printername_0;
1153         uint32_t _ptr_sharename;
1154         TALLOC_CTX *_mem_save_sharename_0;
1155         uint32_t _ptr_portname;
1156         TALLOC_CTX *_mem_save_portname_0;
1157         uint32_t _ptr_drivername;
1158         TALLOC_CTX *_mem_save_drivername_0;
1159         uint32_t _ptr_comment;
1160         TALLOC_CTX *_mem_save_comment_0;
1161         uint32_t _ptr_location;
1162         TALLOC_CTX *_mem_save_location_0;
1163         uint32_t _ptr_devmode;
1164         TALLOC_CTX *_mem_save_devmode_0;
1165         uint32_t _ptr_sepfile;
1166         TALLOC_CTX *_mem_save_sepfile_0;
1167         uint32_t _ptr_printprocessor;
1168         TALLOC_CTX *_mem_save_printprocessor_0;
1169         uint32_t _ptr_datatype;
1170         TALLOC_CTX *_mem_save_datatype_0;
1171         uint32_t _ptr_parameters;
1172         TALLOC_CTX *_mem_save_parameters_0;
1173         uint32_t _ptr_secdesc;
1174         TALLOC_CTX *_mem_save_secdesc_0;
1175         if (ndr_flags & NDR_SCALARS) {
1176                 NDR_CHECK(ndr_pull_align(ndr, 4));
1177                 {
1178                         uint32_t _flags_save_string = ndr->flags;
1179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1181                         if (_ptr_servername) {
1182                                 NDR_PULL_ALLOC(ndr, r->servername);
1183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1184                         } else {
1185                                 r->servername = NULL;
1186                         }
1187                         ndr->flags = _flags_save_string;
1188                 }
1189                 {
1190                         uint32_t _flags_save_string = ndr->flags;
1191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1193                         if (_ptr_printername) {
1194                                 NDR_PULL_ALLOC(ndr, r->printername);
1195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1196                         } else {
1197                                 r->printername = NULL;
1198                         }
1199                         ndr->flags = _flags_save_string;
1200                 }
1201                 {
1202                         uint32_t _flags_save_string = ndr->flags;
1203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1205                         if (_ptr_sharename) {
1206                                 NDR_PULL_ALLOC(ndr, r->sharename);
1207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1208                         } else {
1209                                 r->sharename = NULL;
1210                         }
1211                         ndr->flags = _flags_save_string;
1212                 }
1213                 {
1214                         uint32_t _flags_save_string = ndr->flags;
1215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1217                         if (_ptr_portname) {
1218                                 NDR_PULL_ALLOC(ndr, r->portname);
1219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1220                         } else {
1221                                 r->portname = NULL;
1222                         }
1223                         ndr->flags = _flags_save_string;
1224                 }
1225                 {
1226                         uint32_t _flags_save_string = ndr->flags;
1227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1229                         if (_ptr_drivername) {
1230                                 NDR_PULL_ALLOC(ndr, r->drivername);
1231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1232                         } else {
1233                                 r->drivername = NULL;
1234                         }
1235                         ndr->flags = _flags_save_string;
1236                 }
1237                 {
1238                         uint32_t _flags_save_string = ndr->flags;
1239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1241                         if (_ptr_comment) {
1242                                 NDR_PULL_ALLOC(ndr, r->comment);
1243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1244                         } else {
1245                                 r->comment = NULL;
1246                         }
1247                         ndr->flags = _flags_save_string;
1248                 }
1249                 {
1250                         uint32_t _flags_save_string = ndr->flags;
1251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1253                         if (_ptr_location) {
1254                                 NDR_PULL_ALLOC(ndr, r->location);
1255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1256                         } else {
1257                                 r->location = NULL;
1258                         }
1259                         ndr->flags = _flags_save_string;
1260                 }
1261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1262                 if (_ptr_devmode) {
1263                         NDR_PULL_ALLOC(ndr, r->devmode);
1264                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1265                 } else {
1266                         r->devmode = NULL;
1267                 }
1268                 {
1269                         uint32_t _flags_save_string = ndr->flags;
1270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1272                         if (_ptr_sepfile) {
1273                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1275                         } else {
1276                                 r->sepfile = NULL;
1277                         }
1278                         ndr->flags = _flags_save_string;
1279                 }
1280                 {
1281                         uint32_t _flags_save_string = ndr->flags;
1282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1284                         if (_ptr_printprocessor) {
1285                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1287                         } else {
1288                                 r->printprocessor = NULL;
1289                         }
1290                         ndr->flags = _flags_save_string;
1291                 }
1292                 {
1293                         uint32_t _flags_save_string = ndr->flags;
1294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1296                         if (_ptr_datatype) {
1297                                 NDR_PULL_ALLOC(ndr, r->datatype);
1298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1299                         } else {
1300                                 r->datatype = NULL;
1301                         }
1302                         ndr->flags = _flags_save_string;
1303                 }
1304                 {
1305                         uint32_t _flags_save_string = ndr->flags;
1306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1307                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1308                         if (_ptr_parameters) {
1309                                 NDR_PULL_ALLOC(ndr, r->parameters);
1310                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1311                         } else {
1312                                 r->parameters = NULL;
1313                         }
1314                         ndr->flags = _flags_save_string;
1315                 }
1316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1317                 if (_ptr_secdesc) {
1318                         NDR_PULL_ALLOC(ndr, r->secdesc);
1319                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1320                 } else {
1321                         r->secdesc = NULL;
1322                 }
1323                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1328                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1331         }
1332         if (ndr_flags & NDR_BUFFERS) {
1333                 {
1334                         uint32_t _flags_save_string = ndr->flags;
1335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1336                         if (r->servername) {
1337                                 uint32_t _relative_save_offset;
1338                                 _relative_save_offset = ndr->offset;
1339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1340                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1341                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1344                                 ndr->offset = _relative_save_offset;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         if (r->printername) {
1352                                 uint32_t _relative_save_offset;
1353                                 _relative_save_offset = ndr->offset;
1354                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1355                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1356                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1357                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1358                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1359                                 ndr->offset = _relative_save_offset;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 {
1364                         uint32_t _flags_save_string = ndr->flags;
1365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1366                         if (r->sharename) {
1367                                 uint32_t _relative_save_offset;
1368                                 _relative_save_offset = ndr->offset;
1369                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1370                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1371                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1372                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1373                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1374                                 ndr->offset = _relative_save_offset;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         if (r->portname) {
1382                                 uint32_t _relative_save_offset;
1383                                 _relative_save_offset = ndr->offset;
1384                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1385                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1386                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1387                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1388                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1389                                 ndr->offset = _relative_save_offset;
1390                         }
1391                         ndr->flags = _flags_save_string;
1392                 }
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->drivername) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1400                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1404                                 ndr->offset = _relative_save_offset;
1405                         }
1406                         ndr->flags = _flags_save_string;
1407                 }
1408                 {
1409                         uint32_t _flags_save_string = ndr->flags;
1410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1411                         if (r->comment) {
1412                                 uint32_t _relative_save_offset;
1413                                 _relative_save_offset = ndr->offset;
1414                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1415                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1416                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1417                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1418                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1419                                 ndr->offset = _relative_save_offset;
1420                         }
1421                         ndr->flags = _flags_save_string;
1422                 }
1423                 {
1424                         uint32_t _flags_save_string = ndr->flags;
1425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1426                         if (r->location) {
1427                                 uint32_t _relative_save_offset;
1428                                 _relative_save_offset = ndr->offset;
1429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1430                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1431                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1434                                 ndr->offset = _relative_save_offset;
1435                         }
1436                         ndr->flags = _flags_save_string;
1437                 }
1438                 if (r->devmode) {
1439                         uint32_t _relative_save_offset;
1440                         _relative_save_offset = ndr->offset;
1441                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1442                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1443                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1444                         {
1445                                 struct ndr_pull *_ndr_devmode;
1446                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1447                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1448                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1449                         }
1450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1451                         ndr->offset = _relative_save_offset;
1452                 }
1453                 {
1454                         uint32_t _flags_save_string = ndr->flags;
1455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1456                         if (r->sepfile) {
1457                                 uint32_t _relative_save_offset;
1458                                 _relative_save_offset = ndr->offset;
1459                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1460                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1461                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1462                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1463                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1464                                 ndr->offset = _relative_save_offset;
1465                         }
1466                         ndr->flags = _flags_save_string;
1467                 }
1468                 {
1469                         uint32_t _flags_save_string = ndr->flags;
1470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1471                         if (r->printprocessor) {
1472                                 uint32_t _relative_save_offset;
1473                                 _relative_save_offset = ndr->offset;
1474                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1475                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1476                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1477                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1478                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1479                                 ndr->offset = _relative_save_offset;
1480                         }
1481                         ndr->flags = _flags_save_string;
1482                 }
1483                 {
1484                         uint32_t _flags_save_string = ndr->flags;
1485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1486                         if (r->datatype) {
1487                                 uint32_t _relative_save_offset;
1488                                 _relative_save_offset = ndr->offset;
1489                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1490                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1491                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1492                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1493                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1494                                 ndr->offset = _relative_save_offset;
1495                         }
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         if (r->parameters) {
1502                                 uint32_t _relative_save_offset;
1503                                 _relative_save_offset = ndr->offset;
1504                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1505                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1506                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1507                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1508                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1509                                 ndr->offset = _relative_save_offset;
1510                         }
1511                         ndr->flags = _flags_save_string;
1512                 }
1513                 if (r->secdesc) {
1514                         uint32_t _relative_save_offset;
1515                         _relative_save_offset = ndr->offset;
1516                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1517                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1518                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1519                         {
1520                                 struct ndr_pull *_ndr_secdesc;
1521                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1522                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1523                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1524                         }
1525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1526                         ndr->offset = _relative_save_offset;
1527                 }
1528         }
1529         return NDR_ERR_SUCCESS;
1530 }
1531
1532 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1533 {
1534         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1535         ndr->depth++;
1536         ndr_print_ptr(ndr, "servername", r->servername);
1537         ndr->depth++;
1538         if (r->servername) {
1539                 ndr_print_string(ndr, "servername", r->servername);
1540         }
1541         ndr->depth--;
1542         ndr_print_ptr(ndr, "printername", r->printername);
1543         ndr->depth++;
1544         if (r->printername) {
1545                 ndr_print_string(ndr, "printername", r->printername);
1546         }
1547         ndr->depth--;
1548         ndr_print_ptr(ndr, "sharename", r->sharename);
1549         ndr->depth++;
1550         if (r->sharename) {
1551                 ndr_print_string(ndr, "sharename", r->sharename);
1552         }
1553         ndr->depth--;
1554         ndr_print_ptr(ndr, "portname", r->portname);
1555         ndr->depth++;
1556         if (r->portname) {
1557                 ndr_print_string(ndr, "portname", r->portname);
1558         }
1559         ndr->depth--;
1560         ndr_print_ptr(ndr, "drivername", r->drivername);
1561         ndr->depth++;
1562         if (r->drivername) {
1563                 ndr_print_string(ndr, "drivername", r->drivername);
1564         }
1565         ndr->depth--;
1566         ndr_print_ptr(ndr, "comment", r->comment);
1567         ndr->depth++;
1568         if (r->comment) {
1569                 ndr_print_string(ndr, "comment", r->comment);
1570         }
1571         ndr->depth--;
1572         ndr_print_ptr(ndr, "location", r->location);
1573         ndr->depth++;
1574         if (r->location) {
1575                 ndr_print_string(ndr, "location", r->location);
1576         }
1577         ndr->depth--;
1578         ndr_print_ptr(ndr, "devmode", r->devmode);
1579         ndr->depth++;
1580         if (r->devmode) {
1581                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1582         }
1583         ndr->depth--;
1584         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1585         ndr->depth++;
1586         if (r->sepfile) {
1587                 ndr_print_string(ndr, "sepfile", r->sepfile);
1588         }
1589         ndr->depth--;
1590         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1591         ndr->depth++;
1592         if (r->printprocessor) {
1593                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1594         }
1595         ndr->depth--;
1596         ndr_print_ptr(ndr, "datatype", r->datatype);
1597         ndr->depth++;
1598         if (r->datatype) {
1599                 ndr_print_string(ndr, "datatype", r->datatype);
1600         }
1601         ndr->depth--;
1602         ndr_print_ptr(ndr, "parameters", r->parameters);
1603         ndr->depth++;
1604         if (r->parameters) {
1605                 ndr_print_string(ndr, "parameters", r->parameters);
1606         }
1607         ndr->depth--;
1608         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1609         ndr->depth++;
1610         if (r->secdesc) {
1611                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1612         }
1613         ndr->depth--;
1614         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1615         ndr_print_uint32(ndr, "priority", r->priority);
1616         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1617         ndr_print_uint32(ndr, "starttime", r->starttime);
1618         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1619         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1620         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1621         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1622         ndr->depth--;
1623 }
1624
1625 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1626 {
1627         if (ndr_flags & NDR_SCALARS) {
1628                 NDR_CHECK(ndr_push_align(ndr, 4));
1629                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1630         }
1631         if (ndr_flags & NDR_BUFFERS) {
1632                 if (r->secdesc) {
1633                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1634                         {
1635                                 struct ndr_push *_ndr_secdesc;
1636                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1637                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1638                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1639                         }
1640                 }
1641         }
1642         return NDR_ERR_SUCCESS;
1643 }
1644
1645 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1646 {
1647         uint32_t _ptr_secdesc;
1648         TALLOC_CTX *_mem_save_secdesc_0;
1649         if (ndr_flags & NDR_SCALARS) {
1650                 NDR_CHECK(ndr_pull_align(ndr, 4));
1651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1652                 if (_ptr_secdesc) {
1653                         NDR_PULL_ALLOC(ndr, r->secdesc);
1654                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1655                 } else {
1656                         r->secdesc = NULL;
1657                 }
1658         }
1659         if (ndr_flags & NDR_BUFFERS) {
1660                 if (r->secdesc) {
1661                         uint32_t _relative_save_offset;
1662                         _relative_save_offset = ndr->offset;
1663                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1664                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1665                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1666                         {
1667                                 struct ndr_pull *_ndr_secdesc;
1668                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1669                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1670                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1671                         }
1672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1673                         ndr->offset = _relative_save_offset;
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1680 {
1681         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1682         ndr->depth++;
1683         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1684         ndr->depth++;
1685         if (r->secdesc) {
1686                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1687         }
1688         ndr->depth--;
1689         ndr->depth--;
1690 }
1691
1692 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1693 {
1694         if (ndr_flags & NDR_SCALARS) {
1695                 NDR_CHECK(ndr_push_align(ndr, 4));
1696                 {
1697                         uint32_t _flags_save_string = ndr->flags;
1698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1700                         ndr->flags = _flags_save_string;
1701                 }
1702                 {
1703                         uint32_t _flags_save_string = ndr->flags;
1704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1705                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1706                         ndr->flags = _flags_save_string;
1707                 }
1708                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1709         }
1710         if (ndr_flags & NDR_BUFFERS) {
1711                 {
1712                         uint32_t _flags_save_string = ndr->flags;
1713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1714                         if (r->printername) {
1715                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1716                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1717                         }
1718                         ndr->flags = _flags_save_string;
1719                 }
1720                 {
1721                         uint32_t _flags_save_string = ndr->flags;
1722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1723                         if (r->servername) {
1724                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1725                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1726                         }
1727                         ndr->flags = _flags_save_string;
1728                 }
1729         }
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1734 {
1735         uint32_t _ptr_printername;
1736         TALLOC_CTX *_mem_save_printername_0;
1737         uint32_t _ptr_servername;
1738         TALLOC_CTX *_mem_save_servername_0;
1739         if (ndr_flags & NDR_SCALARS) {
1740                 NDR_CHECK(ndr_pull_align(ndr, 4));
1741                 {
1742                         uint32_t _flags_save_string = ndr->flags;
1743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1745                         if (_ptr_printername) {
1746                                 NDR_PULL_ALLOC(ndr, r->printername);
1747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1748                         } else {
1749                                 r->printername = NULL;
1750                         }
1751                         ndr->flags = _flags_save_string;
1752                 }
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1757                         if (_ptr_servername) {
1758                                 NDR_PULL_ALLOC(ndr, r->servername);
1759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1760                         } else {
1761                                 r->servername = NULL;
1762                         }
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 uint32_t _relative_save_offset;
1773                                 _relative_save_offset = ndr->offset;
1774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1775                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1776                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1779                                 ndr->offset = _relative_save_offset;
1780                         }
1781                         ndr->flags = _flags_save_string;
1782                 }
1783                 {
1784                         uint32_t _flags_save_string = ndr->flags;
1785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1786                         if (r->servername) {
1787                                 uint32_t _relative_save_offset;
1788                                 _relative_save_offset = ndr->offset;
1789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1790                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1791                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1794                                 ndr->offset = _relative_save_offset;
1795                         }
1796                         ndr->flags = _flags_save_string;
1797                 }
1798         }
1799         return NDR_ERR_SUCCESS;
1800 }
1801
1802 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1803 {
1804         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1805         ndr->depth++;
1806         ndr_print_ptr(ndr, "printername", r->printername);
1807         ndr->depth++;
1808         if (r->printername) {
1809                 ndr_print_string(ndr, "printername", r->printername);
1810         }
1811         ndr->depth--;
1812         ndr_print_ptr(ndr, "servername", r->servername);
1813         ndr->depth++;
1814         if (r->servername) {
1815                 ndr_print_string(ndr, "servername", r->servername);
1816         }
1817         ndr->depth--;
1818         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1819         ndr->depth--;
1820 }
1821
1822 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1823 {
1824         if (ndr_flags & NDR_SCALARS) {
1825                 NDR_CHECK(ndr_push_align(ndr, 4));
1826                 {
1827                         uint32_t _flags_save_string = ndr->flags;
1828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1830                         ndr->flags = _flags_save_string;
1831                 }
1832                 {
1833                         uint32_t _flags_save_string = ndr->flags;
1834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1841         }
1842         if (ndr_flags & NDR_BUFFERS) {
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         if (r->printername) {
1847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1848                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1849                         }
1850                         ndr->flags = _flags_save_string;
1851                 }
1852                 {
1853                         uint32_t _flags_save_string = ndr->flags;
1854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1855                         if (r->portname) {
1856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1858                         }
1859                         ndr->flags = _flags_save_string;
1860                 }
1861         }
1862         return NDR_ERR_SUCCESS;
1863 }
1864
1865 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1866 {
1867         uint32_t _ptr_printername;
1868         TALLOC_CTX *_mem_save_printername_0;
1869         uint32_t _ptr_portname;
1870         TALLOC_CTX *_mem_save_portname_0;
1871         if (ndr_flags & NDR_SCALARS) {
1872                 NDR_CHECK(ndr_pull_align(ndr, 4));
1873                 {
1874                         uint32_t _flags_save_string = ndr->flags;
1875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1877                         if (_ptr_printername) {
1878                                 NDR_PULL_ALLOC(ndr, r->printername);
1879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1880                         } else {
1881                                 r->printername = NULL;
1882                         }
1883                         ndr->flags = _flags_save_string;
1884                 }
1885                 {
1886                         uint32_t _flags_save_string = ndr->flags;
1887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1889                         if (_ptr_portname) {
1890                                 NDR_PULL_ALLOC(ndr, r->portname);
1891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1892                         } else {
1893                                 r->portname = NULL;
1894                         }
1895                         ndr->flags = _flags_save_string;
1896                 }
1897                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 {
1903                         uint32_t _flags_save_string = ndr->flags;
1904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1905                         if (r->printername) {
1906                                 uint32_t _relative_save_offset;
1907                                 _relative_save_offset = ndr->offset;
1908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1909                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1910                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1913                                 ndr->offset = _relative_save_offset;
1914                         }
1915                         ndr->flags = _flags_save_string;
1916                 }
1917                 {
1918                         uint32_t _flags_save_string = ndr->flags;
1919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1920                         if (r->portname) {
1921                                 uint32_t _relative_save_offset;
1922                                 _relative_save_offset = ndr->offset;
1923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1924                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1925                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1928                                 ndr->offset = _relative_save_offset;
1929                         }
1930                         ndr->flags = _flags_save_string;
1931                 }
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1937 {
1938         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1939         ndr->depth++;
1940         ndr_print_ptr(ndr, "printername", r->printername);
1941         ndr->depth++;
1942         if (r->printername) {
1943                 ndr_print_string(ndr, "printername", r->printername);
1944         }
1945         ndr->depth--;
1946         ndr_print_ptr(ndr, "portname", r->portname);
1947         ndr->depth++;
1948         if (r->portname) {
1949                 ndr_print_string(ndr, "portname", r->portname);
1950         }
1951         ndr->depth--;
1952         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1953         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1954         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1955         ndr->depth--;
1956 }
1957
1958 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1959 {
1960         if (ndr_flags & NDR_SCALARS) {
1961                 NDR_CHECK(ndr_push_align(ndr, 4));
1962                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1963         }
1964         if (ndr_flags & NDR_BUFFERS) {
1965         }
1966         return NDR_ERR_SUCCESS;
1967 }
1968
1969 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
1970 {
1971         if (ndr_flags & NDR_SCALARS) {
1972                 NDR_CHECK(ndr_pull_align(ndr, 4));
1973                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976         }
1977         return NDR_ERR_SUCCESS;
1978 }
1979
1980 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
1981 {
1982         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
1983         ndr->depth++;
1984         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1985         ndr->depth--;
1986 }
1987
1988 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1989 {
1990         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1991         return NDR_ERR_SUCCESS;
1992 }
1993
1994 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1995 {
1996         uint32_t v;
1997         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1998         *r = v;
1999         return NDR_ERR_SUCCESS;
2000 }
2001
2002 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2003 {
2004         ndr_print_uint32(ndr, name, r);
2005         ndr->depth++;
2006         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2007         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2008         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2009         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2010         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2011         ndr->depth--;
2012 }
2013
2014 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2015 {
2016         if (ndr_flags & NDR_SCALARS) {
2017                 NDR_CHECK(ndr_push_align(ndr, 4));
2018                 {
2019                         uint32_t _flags_save_string = ndr->flags;
2020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2022                         ndr->flags = _flags_save_string;
2023                 }
2024                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2025         }
2026         if (ndr_flags & NDR_BUFFERS) {
2027                 {
2028                         uint32_t _flags_save_string = ndr->flags;
2029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2030                         if (r->guid) {
2031                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2032                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2033                         }
2034                         ndr->flags = _flags_save_string;
2035                 }
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2041 {
2042         uint32_t _ptr_guid;
2043         TALLOC_CTX *_mem_save_guid_0;
2044         if (ndr_flags & NDR_SCALARS) {
2045                 NDR_CHECK(ndr_pull_align(ndr, 4));
2046                 {
2047                         uint32_t _flags_save_string = ndr->flags;
2048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2050                         if (_ptr_guid) {
2051                                 NDR_PULL_ALLOC(ndr, r->guid);
2052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2053                         } else {
2054                                 r->guid = NULL;
2055                         }
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 uint32_t _relative_save_offset;
2066                                 _relative_save_offset = ndr->offset;
2067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2068                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2069                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2072                                 ndr->offset = _relative_save_offset;
2073                         }
2074                         ndr->flags = _flags_save_string;
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2081 {
2082         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2083         ndr->depth++;
2084         ndr_print_ptr(ndr, "guid", r->guid);
2085         ndr->depth++;
2086         if (r->guid) {
2087                 ndr_print_string(ndr, "guid", r->guid);
2088         }
2089         ndr->depth--;
2090         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2091         ndr->depth--;
2092 }
2093
2094 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2095 {
2096         if (ndr_flags & NDR_SCALARS) {
2097                 NDR_CHECK(ndr_push_align(ndr, 4));
2098                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2099         }
2100         if (ndr_flags & NDR_BUFFERS) {
2101                 if (r->devmode) {
2102                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2103                         {
2104                                 struct ndr_push *_ndr_devmode;
2105                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2106                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2107                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2108                         }
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2115 {
2116         uint32_t _ptr_devmode;
2117         TALLOC_CTX *_mem_save_devmode_0;
2118         if (ndr_flags & NDR_SCALARS) {
2119                 NDR_CHECK(ndr_pull_align(ndr, 4));
2120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2121                 if (_ptr_devmode) {
2122                         NDR_PULL_ALLOC(ndr, r->devmode);
2123                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2124                 } else {
2125                         r->devmode = NULL;
2126                 }
2127         }
2128         if (ndr_flags & NDR_BUFFERS) {
2129                 if (r->devmode) {
2130                         uint32_t _relative_save_offset;
2131                         _relative_save_offset = ndr->offset;
2132                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2133                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2134                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2135                         {
2136                                 struct ndr_pull *_ndr_devmode;
2137                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2138                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2139                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2140                         }
2141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2142                         ndr->offset = _relative_save_offset;
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2149 {
2150         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2151         ndr->depth++;
2152         ndr_print_ptr(ndr, "devmode", r->devmode);
2153         ndr->depth++;
2154         if (r->devmode) {
2155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2156         }
2157         ndr->depth--;
2158         ndr->depth--;
2159 }
2160
2161 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2162 {
2163         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2164         if (ndr_flags & NDR_SCALARS) {
2165                 int level = ndr_push_get_switch_value(ndr, r);
2166                 switch (level) {
2167                         case 0: {
2168                                 NDR_CHECK(ndr_push_align(ndr, 4));
2169                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2170                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2171                         break; }
2172
2173                         case 1: {
2174                                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2176                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2177                         break; }
2178
2179                         case 2: {
2180                                 NDR_CHECK(ndr_push_align(ndr, 4));
2181                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2182                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2183                         break; }
2184
2185                         case 3: {
2186                                 NDR_CHECK(ndr_push_align(ndr, 4));
2187                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2188                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2189                         break; }
2190
2191                         case 4: {
2192                                 NDR_CHECK(ndr_push_align(ndr, 4));
2193                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2194                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2195                         break; }
2196
2197                         case 5: {
2198                                 NDR_CHECK(ndr_push_align(ndr, 4));
2199                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2200                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2201                         break; }
2202
2203                         case 6: {
2204                                 NDR_CHECK(ndr_push_align(ndr, 4));
2205                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2206                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2207                         break; }
2208
2209                         case 7: {
2210                                 NDR_CHECK(ndr_push_align(ndr, 4));
2211                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2212                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2213                         break; }
2214
2215                         case 8: {
2216                                 NDR_CHECK(ndr_push_align(ndr, 4));
2217                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2218                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2219                         break; }
2220
2221                         case 9: {
2222                                 NDR_CHECK(ndr_push_align(ndr, 4));
2223                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2224                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2225                         break; }
2226
2227                         default: {
2228                         break; }
2229
2230                 }
2231         }
2232         if (ndr_flags & NDR_BUFFERS) {
2233                 int level = ndr_push_get_switch_value(ndr, r);
2234                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2235                 switch (level) {
2236                         case 0:
2237                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2238                         break;
2239
2240                         case 1:
2241                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2242                         break;
2243
2244                         case 2:
2245                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2246                         break;
2247
2248                         case 3:
2249                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2250                         break;
2251
2252                         case 4:
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2254                         break;
2255
2256                         case 5:
2257                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2258                         break;
2259
2260                         case 6:
2261                         break;
2262
2263                         case 7:
2264                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2265                         break;
2266
2267                         case 8:
2268                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2269                         break;
2270
2271                         case 9:
2272                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2273                         break;
2274
2275                         default:
2276                         break;
2277
2278                 }
2279         }
2280         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2281         return NDR_ERR_SUCCESS;
2282 }
2283
2284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2285 {
2286         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2287         int level;
2288         level = ndr_pull_get_switch_value(ndr, r);
2289         if (ndr_flags & NDR_SCALARS) {
2290                 switch (level) {
2291                         case 0: {
2292                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2293                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2294                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2295                         break; }
2296
2297                         case 1: {
2298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2300                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2301                         break; }
2302
2303                         case 2: {
2304                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2305                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2306                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2307                         break; }
2308
2309                         case 3: {
2310                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2311                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2312                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2313                         break; }
2314
2315                         case 4: {
2316                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2317                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2318                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2319                         break; }
2320
2321                         case 5: {
2322                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2323                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2324                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2325                         break; }
2326
2327                         case 6: {
2328                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2329                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2330                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2331                         break; }
2332
2333                         case 7: {
2334                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2335                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2336                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2337                         break; }
2338
2339                         case 8: {
2340                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2341                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2342                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2343                         break; }
2344
2345                         case 9: {
2346                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2347                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2348                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2349                         break; }
2350
2351                         default: {
2352                         break; }
2353
2354                 }
2355         }
2356         if (ndr_flags & NDR_BUFFERS) {
2357                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2358                 switch (level) {
2359                         case 0:
2360                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2361                         break;
2362
2363                         case 1:
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2365                         break;
2366
2367                         case 2:
2368                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2369                         break;
2370
2371                         case 3:
2372                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2373                         break;
2374
2375                         case 4:
2376                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2377                         break;
2378
2379                         case 5:
2380                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2381                         break;
2382
2383                         case 6:
2384                         break;
2385
2386                         case 7:
2387                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2388                         break;
2389
2390                         case 8:
2391                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2392                         break;
2393
2394                         case 9:
2395                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2396                         break;
2397
2398                         default:
2399                         break;
2400
2401                 }
2402         }
2403         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2408 {
2409         int level;
2410         level = ndr_print_get_switch_value(ndr, r);
2411         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2412         switch (level) {
2413                 case 0:
2414                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2415                 break;
2416
2417                 case 1:
2418                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2419                 break;
2420
2421                 case 2:
2422                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2423                 break;
2424
2425                 case 3:
2426                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2427                 break;
2428
2429                 case 4:
2430                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2431                 break;
2432
2433                 case 5:
2434                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2435                 break;
2436
2437                 case 6:
2438                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2439                 break;
2440
2441                 case 7:
2442                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2443                 break;
2444
2445                 case 8:
2446                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2447                 break;
2448
2449                 case 9:
2450                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2451                 break;
2452
2453                 default:
2454                 break;
2455
2456         }
2457 }
2458
2459 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2460 {
2461         if (ndr_flags & NDR_SCALARS) {
2462                 NDR_CHECK(ndr_push_align(ndr, 4));
2463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2465         }
2466         if (ndr_flags & NDR_BUFFERS) {
2467                 if (r->devmode) {
2468                         {
2469                                 struct ndr_push *_ndr_devmode;
2470                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2471                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2472                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2473                         }
2474                 }
2475         }
2476         return NDR_ERR_SUCCESS;
2477 }
2478
2479 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2480 {
2481         uint32_t _ptr_devmode;
2482         TALLOC_CTX *_mem_save_devmode_0;
2483         if (ndr_flags & NDR_SCALARS) {
2484                 NDR_CHECK(ndr_pull_align(ndr, 4));
2485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2487                 if (_ptr_devmode) {
2488                         NDR_PULL_ALLOC(ndr, r->devmode);
2489                 } else {
2490                         r->devmode = NULL;
2491                 }
2492         }
2493         if (ndr_flags & NDR_BUFFERS) {
2494                 if (r->devmode) {
2495                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2497                         {
2498                                 struct ndr_pull *_ndr_devmode;
2499                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2500                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2501                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2502                         }
2503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2504                 }
2505         }
2506         return NDR_ERR_SUCCESS;
2507 }
2508
2509 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2510 {
2511         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2512         ndr->depth++;
2513         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2514         ndr_print_ptr(ndr, "devmode", r->devmode);
2515         ndr->depth++;
2516         if (r->devmode) {
2517                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2518         }
2519         ndr->depth--;
2520         ndr->depth--;
2521 }
2522
2523 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2524 {
2525         if (ndr_flags & NDR_SCALARS) {
2526                 NDR_CHECK(ndr_push_align(ndr, 4));
2527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2528                 {
2529                         uint32_t _flags_save_string = ndr->flags;
2530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2532                         ndr->flags = _flags_save_string;
2533                 }
2534                 {
2535                         uint32_t _flags_save_string = ndr->flags;
2536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2538                         ndr->flags = _flags_save_string;
2539                 }
2540                 {
2541                         uint32_t _flags_save_string = ndr->flags;
2542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2544                         ndr->flags = _flags_save_string;
2545                 }
2546                 {
2547                         uint32_t _flags_save_string = ndr->flags;
2548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2550                         ndr->flags = _flags_save_string;
2551                 }
2552                 {
2553                         uint32_t _flags_save_string = ndr->flags;
2554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2556                         ndr->flags = _flags_save_string;
2557                 }
2558                 {
2559                         uint32_t _flags_save_string = ndr->flags;
2560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2562                         ndr->flags = _flags_save_string;
2563                 }
2564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
2565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2569                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2570         }
2571         if (ndr_flags & NDR_BUFFERS) {
2572                 {
2573                         uint32_t _flags_save_string = ndr->flags;
2574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2575                         if (r->printer_name) {
2576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2578                         }
2579                         ndr->flags = _flags_save_string;
2580                 }
2581                 {
2582                         uint32_t _flags_save_string = ndr->flags;
2583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2584                         if (r->server_name) {
2585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2587                         }
2588                         ndr->flags = _flags_save_string;
2589                 }
2590                 {
2591                         uint32_t _flags_save_string = ndr->flags;
2592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2593                         if (r->user_name) {
2594                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2596                         }
2597                         ndr->flags = _flags_save_string;
2598                 }
2599                 {
2600                         uint32_t _flags_save_string = ndr->flags;
2601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2602                         if (r->document_name) {
2603                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2605                         }
2606                         ndr->flags = _flags_save_string;
2607                 }
2608                 {
2609                         uint32_t _flags_save_string = ndr->flags;
2610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2611                         if (r->data_type) {
2612                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2613                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2614                         }
2615                         ndr->flags = _flags_save_string;
2616                 }
2617                 {
2618                         uint32_t _flags_save_string = ndr->flags;
2619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2620                         if (r->text_status) {
2621                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2622                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2623                         }
2624                         ndr->flags = _flags_save_string;
2625                 }
2626         }
2627         return NDR_ERR_SUCCESS;
2628 }
2629
2630 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2631 {
2632         uint32_t _ptr_printer_name;
2633         TALLOC_CTX *_mem_save_printer_name_0;
2634         uint32_t _ptr_server_name;
2635         TALLOC_CTX *_mem_save_server_name_0;
2636         uint32_t _ptr_user_name;
2637         TALLOC_CTX *_mem_save_user_name_0;
2638         uint32_t _ptr_document_name;
2639         TALLOC_CTX *_mem_save_document_name_0;
2640         uint32_t _ptr_data_type;
2641         TALLOC_CTX *_mem_save_data_type_0;
2642         uint32_t _ptr_text_status;
2643         TALLOC_CTX *_mem_save_text_status_0;
2644         if (ndr_flags & NDR_SCALARS) {
2645                 NDR_CHECK(ndr_pull_align(ndr, 4));
2646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2647                 {
2648                         uint32_t _flags_save_string = ndr->flags;
2649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2651                         if (_ptr_printer_name) {
2652                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2654                         } else {
2655                                 r->printer_name = NULL;
2656                         }
2657                         ndr->flags = _flags_save_string;
2658                 }
2659                 {
2660                         uint32_t _flags_save_string = ndr->flags;
2661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2663                         if (_ptr_server_name) {
2664                                 NDR_PULL_ALLOC(ndr, r->server_name);
2665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2666                         } else {
2667                                 r->server_name = NULL;
2668                         }
2669                         ndr->flags = _flags_save_string;
2670                 }
2671                 {
2672                         uint32_t _flags_save_string = ndr->flags;
2673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2675                         if (_ptr_user_name) {
2676                                 NDR_PULL_ALLOC(ndr, r->user_name);
2677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2678                         } else {
2679                                 r->user_name = NULL;
2680                         }
2681                         ndr->flags = _flags_save_string;
2682                 }
2683                 {
2684                         uint32_t _flags_save_string = ndr->flags;
2685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2687                         if (_ptr_document_name) {
2688                                 NDR_PULL_ALLOC(ndr, r->document_name);
2689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2690                         } else {
2691                                 r->document_name = NULL;
2692                         }
2693                         ndr->flags = _flags_save_string;
2694                 }
2695                 {
2696                         uint32_t _flags_save_string = ndr->flags;
2697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2699                         if (_ptr_data_type) {
2700                                 NDR_PULL_ALLOC(ndr, r->data_type);
2701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2702                         } else {
2703                                 r->data_type = NULL;
2704                         }
2705                         ndr->flags = _flags_save_string;
2706                 }
2707                 {
2708                         uint32_t _flags_save_string = ndr->flags;
2709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2710                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2711                         if (_ptr_text_status) {
2712                                 NDR_PULL_ALLOC(ndr, r->text_status);
2713                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2714                         } else {
2715                                 r->text_status = NULL;
2716                         }
2717                         ndr->flags = _flags_save_string;
2718                 }
2719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
2720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2724                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2725         }
2726         if (ndr_flags & NDR_BUFFERS) {
2727                 {
2728                         uint32_t _flags_save_string = ndr->flags;
2729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2730                         if (r->printer_name) {
2731                                 uint32_t _relative_save_offset;
2732                                 _relative_save_offset = ndr->offset;
2733                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2734                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2735                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2736                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2737                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2738                                 ndr->offset = _relative_save_offset;
2739                         }
2740                         ndr->flags = _flags_save_string;
2741                 }
2742                 {
2743                         uint32_t _flags_save_string = ndr->flags;
2744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2745                         if (r->server_name) {
2746                                 uint32_t _relative_save_offset;
2747                                 _relative_save_offset = ndr->offset;
2748                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2749                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2750                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2751                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2752                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2753                                 ndr->offset = _relative_save_offset;
2754                         }
2755                         ndr->flags = _flags_save_string;
2756                 }
2757                 {
2758                         uint32_t _flags_save_string = ndr->flags;
2759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2760                         if (r->user_name) {
2761                                 uint32_t _relative_save_offset;
2762                                 _relative_save_offset = ndr->offset;
2763                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2764                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2765                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2766                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2767                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2768                                 ndr->offset = _relative_save_offset;
2769                         }
2770                         ndr->flags = _flags_save_string;
2771                 }
2772                 {
2773                         uint32_t _flags_save_string = ndr->flags;
2774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2775                         if (r->document_name) {
2776                                 uint32_t _relative_save_offset;
2777                                 _relative_save_offset = ndr->offset;
2778                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2779                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2780                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2781                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2782                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2783                                 ndr->offset = _relative_save_offset;
2784                         }
2785                         ndr->flags = _flags_save_string;
2786                 }
2787                 {
2788                         uint32_t _flags_save_string = ndr->flags;
2789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2790                         if (r->data_type) {
2791                                 uint32_t _relative_save_offset;
2792                                 _relative_save_offset = ndr->offset;
2793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2794                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2795                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2798                                 ndr->offset = _relative_save_offset;
2799                         }
2800                         ndr->flags = _flags_save_string;
2801                 }
2802                 {
2803                         uint32_t _flags_save_string = ndr->flags;
2804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2805                         if (r->text_status) {
2806                                 uint32_t _relative_save_offset;
2807                                 _relative_save_offset = ndr->offset;
2808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2809                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2810                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2813                                 ndr->offset = _relative_save_offset;
2814                         }
2815                         ndr->flags = _flags_save_string;
2816                 }
2817         }
2818         return NDR_ERR_SUCCESS;
2819 }
2820
2821 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2822 {
2823         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2824         ndr->depth++;
2825         ndr_print_uint32(ndr, "job_id", r->job_id);
2826         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2827         ndr->depth++;
2828         if (r->printer_name) {
2829                 ndr_print_string(ndr, "printer_name", r->printer_name);
2830         }
2831         ndr->depth--;
2832         ndr_print_ptr(ndr, "server_name", r->server_name);
2833         ndr->depth++;
2834         if (r->server_name) {
2835                 ndr_print_string(ndr, "server_name", r->server_name);
2836         }
2837         ndr->depth--;
2838         ndr_print_ptr(ndr, "user_name", r->user_name);
2839         ndr->depth++;
2840         if (r->user_name) {
2841                 ndr_print_string(ndr, "user_name", r->user_name);
2842         }
2843         ndr->depth--;
2844         ndr_print_ptr(ndr, "document_name", r->document_name);
2845         ndr->depth++;
2846         if (r->document_name) {
2847                 ndr_print_string(ndr, "document_name", r->document_name);
2848         }
2849         ndr->depth--;
2850         ndr_print_ptr(ndr, "data_type", r->data_type);
2851         ndr->depth++;
2852         if (r->data_type) {
2853                 ndr_print_string(ndr, "data_type", r->data_type);
2854         }
2855         ndr->depth--;
2856         ndr_print_ptr(ndr, "text_status", r->text_status);
2857         ndr->depth++;
2858         if (r->text_status) {
2859                 ndr_print_string(ndr, "text_status", r->text_status);
2860         }
2861         ndr->depth--;
2862         ndr_print_uint32(ndr, "status", r->status);
2863         ndr_print_uint32(ndr, "priority", r->priority);
2864         ndr_print_uint32(ndr, "position", r->position);
2865         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2866         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2867         ndr_print_spoolss_Time(ndr, "time", &r->time);
2868         ndr->depth--;
2869 }
2870
2871 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
2872 {
2873         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2874         if (ndr_flags & NDR_SCALARS) {
2875                 int level = ndr_push_get_switch_value(ndr, r);
2876                 switch (level) {
2877                         case 1: {
2878                                 NDR_CHECK(ndr_push_align(ndr, 4));
2879                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2880                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2881                         break; }
2882
2883                         case 2: {
2884                         break; }
2885
2886                         case 3: {
2887                         break; }
2888
2889                         default: {
2890                         break; }
2891
2892                 }
2893         }
2894         if (ndr_flags & NDR_BUFFERS) {
2895                 int level = ndr_push_get_switch_value(ndr, r);
2896                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2897                 switch (level) {
2898                         case 1:
2899                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2900                         break;
2901
2902                         case 2:
2903                         break;
2904
2905                         case 3:
2906                         break;
2907
2908                         default:
2909                         break;
2910
2911                 }
2912         }
2913         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2914         return NDR_ERR_SUCCESS;
2915 }
2916
2917 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
2918 {
2919         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2920         int level;
2921         level = ndr_pull_get_switch_value(ndr, r);
2922         if (ndr_flags & NDR_SCALARS) {
2923                 switch (level) {
2924                         case 1: {
2925                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2926                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2927                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2928                         break; }
2929
2930                         case 2: {
2931                         break; }
2932
2933                         case 3: {
2934                         break; }
2935
2936                         default: {
2937                         break; }
2938
2939                 }
2940         }
2941         if (ndr_flags & NDR_BUFFERS) {
2942                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2943                 switch (level) {
2944                         case 1:
2945                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2946                         break;
2947
2948                         case 2:
2949                         break;
2950
2951                         case 3:
2952                         break;
2953
2954                         default:
2955                         break;
2956
2957                 }
2958         }
2959         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2960         return NDR_ERR_SUCCESS;
2961 }
2962
2963 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
2964 {
2965         int level;
2966         level = ndr_print_get_switch_value(ndr, r);
2967         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
2968         switch (level) {
2969                 case 1:
2970                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
2971                 break;
2972
2973                 case 2:
2974                 break;
2975
2976                 case 3:
2977                 break;
2978
2979                 default:
2980                 break;
2981
2982         }
2983 }
2984
2985 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
2986 {
2987         if (ndr_flags & NDR_SCALARS) {
2988                 NDR_CHECK(ndr_push_align(ndr, 4));
2989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2990                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
2991                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
2992         }
2993         if (ndr_flags & NDR_BUFFERS) {
2994                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
2995         }
2996         return NDR_ERR_SUCCESS;
2997 }
2998
2999 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
3000 {
3001         if (ndr_flags & NDR_SCALARS) {
3002                 NDR_CHECK(ndr_pull_align(ndr, 4));
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3004                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
3005                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
3009         }
3010         return NDR_ERR_SUCCESS;
3011 }
3012
3013 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
3014 {
3015         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
3016         ndr->depth++;
3017         ndr_print_uint32(ndr, "level", r->level);
3018         ndr_print_set_switch_value(ndr, &r->info, r->level);
3019         ndr_print_spoolss_JobInfo(ndr, "info", &r->info);
3020         ndr->depth--;
3021 }
3022
3023 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
3024 {
3025         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3026         return NDR_ERR_SUCCESS;
3027 }
3028
3029 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
3030 {
3031         uint32_t v;
3032         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3033         *r = v;
3034         return NDR_ERR_SUCCESS;
3035 }
3036
3037 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
3038 {
3039         const char *val = NULL;
3040
3041         switch (r) {
3042                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
3043                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
3044                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
3045                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
3046                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
3047                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
3048                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
3049         }
3050         ndr_print_enum(ndr, name, "ENUM", val, r);
3051 }
3052
3053 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
3054 {
3055         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3056         return NDR_ERR_SUCCESS;
3057 }
3058
3059 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
3060 {
3061         uint32_t v;
3062         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3063         *r = v;
3064         return NDR_ERR_SUCCESS;
3065 }
3066
3067 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
3068 {
3069         const char *val = NULL;
3070
3071         switch (r) {
3072                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
3073                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
3074                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
3075                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
3076                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
3077         }
3078         ndr_print_enum(ndr, name, "ENUM", val, r);
3079 }
3080
3081 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
3082 {
3083         if (ndr_flags & NDR_SCALARS) {
3084                 NDR_CHECK(ndr_push_align(ndr, 4));
3085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
3089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
3090                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
3092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
3094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
3095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
3096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
3097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
3098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
3099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
3100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
3101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
3102                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
3103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
3104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
3105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
3106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
3107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
3108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
3109                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
3110                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
3111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
3112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
3113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
3114         }
3115         if (ndr_flags & NDR_BUFFERS) {
3116                 if (r->servername) {
3117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3121                 }
3122                 if (r->printername) {
3123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
3133 {
3134         uint32_t _ptr_servername;
3135         TALLOC_CTX *_mem_save_servername_0;
3136         uint32_t _ptr_printername;
3137         TALLOC_CTX *_mem_save_printername_0;
3138         if (ndr_flags & NDR_SCALARS) {
3139                 NDR_CHECK(ndr_pull_align(ndr, 4));
3140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3141                 if (_ptr_servername) {
3142                         NDR_PULL_ALLOC(ndr, r->servername);
3143                 } else {
3144                         r->servername = NULL;
3145                 }
3146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3147                 if (_ptr_printername) {
3148                         NDR_PULL_ALLOC(ndr, r->printername);
3149                 } else {
3150                         r->printername = NULL;
3151                 }
3152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
3154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
3155                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
3157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
3159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
3160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
3161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
3162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
3163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
3164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
3165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
3166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
3167                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
3168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
3169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
3170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
3171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
3172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
3173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
3174                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
3175                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
3176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
3177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
3178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
3179         }
3180         if (ndr_flags & NDR_BUFFERS) {
3181                 if (r->servername) {
3182                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3183                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3186                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3187                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3188                         }
3189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3192                 }
3193                 if (r->printername) {
3194                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3195                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3198                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3200                         }
3201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3204                 }
3205         }
3206         return NDR_ERR_SUCCESS;
3207 }
3208
3209 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
3210 {
3211         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
3212         ndr->depth++;
3213         ndr_print_ptr(ndr, "servername", r->servername);
3214         ndr->depth++;
3215         if (r->servername) {
3216                 ndr_print_string(ndr, "servername", r->servername);
3217         }
3218         ndr->depth--;
3219         ndr_print_ptr(ndr, "printername", r->printername);
3220         ndr->depth++;
3221         if (r->printername) {
3222                 ndr_print_string(ndr, "printername", r->printername);
3223         }
3224         ndr->depth--;
3225         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3226         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
3227         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
3228         ndr_print_spoolss_Time(ndr, "time", &r->time);
3229         ndr_print_uint32(ndr, "global_counter", r->global_counter);
3230         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3231         ndr_print_uint32(ndr, "version", r->version);
3232         ndr_print_uint32(ndr, "free_build", r->free_build);
3233         ndr_print_uint32(ndr, "spooling", r->spooling);
3234         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
3235         ndr_print_uint32(ndr, "session_counter", r->session_counter);
3236         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
3237         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
3238         ndr_print_uint32(ndr, "job_error", r->job_error);
3239         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
3240         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
3241         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
3242         ndr_print_uint32(ndr, "change_id", r->change_id);
3243         ndr_print_WERROR(ndr, "last_error", r->last_error);
3244         ndr_print_uint32(ndr, "status", r->status);
3245         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
3246         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
3247         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
3248         ndr_print_uint16(ndr, "processor_level", r->processor_level);
3249         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
3250         ndr_print_uint32(ndr, "reserved2", r->reserved2);
3251         ndr_print_uint32(ndr, "reserved3", r->reserved3);
3252         ndr->depth--;
3253 }
3254
3255 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
3256 {
3257         if (ndr_flags & NDR_SCALARS) {
3258                 NDR_CHECK(ndr_push_align(ndr, 4));
3259                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
3260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
3262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3263         }
3264         if (ndr_flags & NDR_BUFFERS) {
3265                 if (r->name) {
3266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3270                 }
3271                 if (r->description) {
3272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3276                 }
3277                 if (r->comment) {
3278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3282                 }
3283         }
3284         return NDR_ERR_SUCCESS;
3285 }
3286
3287 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
3288 {
3289         uint32_t _ptr_name;
3290         TALLOC_CTX *_mem_save_name_0;
3291         uint32_t _ptr_description;
3292         TALLOC_CTX *_mem_save_description_0;
3293         uint32_t _ptr_comment;
3294         TALLOC_CTX *_mem_save_comment_0;
3295         if (ndr_flags & NDR_SCALARS) {
3296                 NDR_CHECK(ndr_pull_align(ndr, 4));
3297                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3299                 if (_ptr_name) {
3300                         NDR_PULL_ALLOC(ndr, r->name);
3301                 } else {
3302                         r->name = NULL;
3303                 }
3304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
3305                 if (_ptr_description) {
3306                         NDR_PULL_ALLOC(ndr, r->description);
3307                 } else {
3308                         r->description = NULL;
3309                 }
3310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3311                 if (_ptr_comment) {
3312                         NDR_PULL_ALLOC(ndr, r->comment);
3313                 } else {
3314                         r->comment = NULL;
3315                 }
3316         }
3317         if (ndr_flags & NDR_BUFFERS) {
3318                 if (r->name) {
3319                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3320                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3323                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3324                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3325                         }
3326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3329                 }
3330                 if (r->description) {
3331                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
3332                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
3333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
3334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
3335                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
3336                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
3337                         }
3338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
3339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
3340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
3341                 }
3342                 if (r->comment) {
3343                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3347                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3349                         }
3350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3353                 }
3354         }
3355         return NDR_ERR_SUCCESS;
3356 }
3357
3358 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
3359 {
3360         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
3361         ndr->depth++;
3362         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
3363         ndr_print_ptr(ndr, "name", r->name);
3364         ndr->depth++;
3365         if (r->name) {
3366                 ndr_print_string(ndr, "name", r->name);
3367         }
3368         ndr->depth--;
3369         ndr_print_ptr(ndr, "description", r->description);
3370         ndr->depth++;
3371         if (r->description) {
3372                 ndr_print_string(ndr, "description", r->description);
3373         }
3374         ndr->depth--;
3375         ndr_print_ptr(ndr, "comment", r->comment);
3376         ndr->depth++;
3377         if (r->comment) {
3378                 ndr_print_string(ndr, "comment", r->comment);
3379         }
3380         ndr->depth--;
3381         ndr->depth--;
3382 }
3383
3384 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
3385 {
3386         if (ndr_flags & NDR_SCALARS) {
3387                 NDR_CHECK(ndr_push_align(ndr, 4));
3388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
3391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
3392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
3393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
3395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
3397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
3398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
3399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
3400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3401                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
3404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
3405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
3406                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
3407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
3409         }
3410         if (ndr_flags & NDR_BUFFERS) {
3411                 if (r->servername) {
3412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3416                 }
3417                 if (r->printername) {
3418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3422                 }
3423                 if (r->sharename) {
3424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3428                 }
3429                 if (r->portname) {
3430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3434                 }
3435                 if (r->drivername) {
3436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3440                 }
3441                 if (r->comment) {
3442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3446                 }
3447                 if (r->location) {
3448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3452                 }
3453                 if (r->devmode) {
3454                         {
3455                                 struct ndr_push *_ndr_devmode;
3456                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3457                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3458                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3459                         }
3460                 }
3461                 if (r->sepfile) {
3462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3465                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3466                 }
3467                 if (r->printprocessor) {
3468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3472                 }
3473                 if (r->datatype) {
3474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3478                 }
3479                 if (r->parameters) {
3480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3484                 }
3485                 if (r->secdesc) {
3486                         {
3487                                 struct ndr_push *_ndr_secdesc;
3488                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3489                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3490                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3491                         }
3492                 }
3493         }
3494         return NDR_ERR_SUCCESS;
3495 }
3496
3497 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
3498 {
3499         uint32_t _ptr_servername;
3500         TALLOC_CTX *_mem_save_servername_0;
3501         uint32_t _ptr_printername;
3502         TALLOC_CTX *_mem_save_printername_0;
3503         uint32_t _ptr_sharename;
3504         TALLOC_CTX *_mem_save_sharename_0;
3505         uint32_t _ptr_portname;
3506         TALLOC_CTX *_mem_save_portname_0;
3507         uint32_t _ptr_drivername;
3508         TALLOC_CTX *_mem_save_drivername_0;
3509         uint32_t _ptr_comment;
3510         TALLOC_CTX *_mem_save_comment_0;
3511         uint32_t _ptr_location;
3512         TALLOC_CTX *_mem_save_location_0;
3513         uint32_t _ptr_devmode;
3514         TALLOC_CTX *_mem_save_devmode_0;
3515         uint32_t _ptr_sepfile;
3516         TALLOC_CTX *_mem_save_sepfile_0;
3517         uint32_t _ptr_printprocessor;
3518         TALLOC_CTX *_mem_save_printprocessor_0;
3519         uint32_t _ptr_datatype;
3520         TALLOC_CTX *_mem_save_datatype_0;
3521         uint32_t _ptr_parameters;
3522         TALLOC_CTX *_mem_save_parameters_0;
3523         uint32_t _ptr_secdesc;
3524         TALLOC_CTX *_mem_save_secdesc_0;
3525         if (ndr_flags & NDR_SCALARS) {
3526                 NDR_CHECK(ndr_pull_align(ndr, 4));
3527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3528                 if (_ptr_servername) {
3529                         NDR_PULL_ALLOC(ndr, r->servername);
3530                 } else {
3531                         r->servername = NULL;
3532                 }
3533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3534                 if (_ptr_printername) {
3535                         NDR_PULL_ALLOC(ndr, r->printername);
3536                 } else {
3537                         r->printername = NULL;
3538                 }
3539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3540                 if (_ptr_sharename) {
3541                         NDR_PULL_ALLOC(ndr, r->sharename);
3542                 } else {
3543                         r->sharename = NULL;
3544                 }
3545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
3546                 if (_ptr_portname) {
3547                         NDR_PULL_ALLOC(ndr, r->portname);
3548                 } else {
3549                         r->portname = NULL;
3550                 }
3551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
3552                 if (_ptr_drivername) {
3553                         NDR_PULL_ALLOC(ndr, r->drivername);
3554                 } else {
3555                         r->drivername = NULL;
3556                 }
3557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3558                 if (_ptr_comment) {
3559                         NDR_PULL_ALLOC(ndr, r->comment);
3560                 } else {
3561                         r->comment = NULL;
3562                 }
3563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
3564                 if (_ptr_location) {
3565                         NDR_PULL_ALLOC(ndr, r->location);
3566                 } else {
3567                         r->location = NULL;
3568                 }
3569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3570                 if (_ptr_devmode) {
3571                         NDR_PULL_ALLOC(ndr, r->devmode);
3572                 } else {
3573                         r->devmode = NULL;
3574                 }
3575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
3576                 if (_ptr_sepfile) {
3577                         NDR_PULL_ALLOC(ndr, r->sepfile);
3578                 } else {
3579                         r->sepfile = NULL;
3580                 }
3581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
3582                 if (_ptr_printprocessor) {
3583                         NDR_PULL_ALLOC(ndr, r->printprocessor);
3584                 } else {
3585                         r->printprocessor = NULL;
3586                 }
3587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
3588                 if (_ptr_datatype) {
3589                         NDR_PULL_ALLOC(ndr, r->datatype);
3590                 } else {
3591                         r->datatype = NULL;
3592                 }
3593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3594                 if (_ptr_parameters) {
3595                         NDR_PULL_ALLOC(ndr, r->parameters);
3596                 } else {
3597                         r->parameters = NULL;
3598                 }
3599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3600                 if (_ptr_secdesc) {
3601                         NDR_PULL_ALLOC(ndr, r->secdesc);
3602                 } else {
3603                         r->secdesc = NULL;
3604                 }
3605                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
3609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
3610                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
3611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
3613         }
3614         if (ndr_flags & NDR_BUFFERS) {
3615                 if (r->servername) {
3616                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3617                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3620                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3621                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3622                         }
3623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3626                 }
3627                 if (r->printername) {
3628                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3629                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3632                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3633                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3634                         }
3635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3638                 }
3639                 if (r->sharename) {
3640                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3641                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
3642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
3643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
3644                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
3645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
3646                         }
3647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
3648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
3649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3650                 }
3651                 if (r->portname) {
3652                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3653                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
3654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
3655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
3656                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
3657                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
3658                         }
3659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
3660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
3661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
3662                 }
3663                 if (r->drivername) {
3664                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3665                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
3666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
3667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
3668                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
3669                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
3670                         }
3671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
3672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
3673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
3674                 }
3675                 if (r->comment) {
3676                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3677                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3680                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3681                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3682                         }
3683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3686                 }
3687                 if (r->location) {
3688                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
3689                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
3690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
3691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
3692                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
3693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
3694                         }
3695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
3696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
3697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
3698                 }
3699                 if (r->devmode) {
3700                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3701                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3702                         {
3703                                 struct ndr_pull *_ndr_devmode;
3704                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3705                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3706                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3707                         }
3708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3709                 }
3710                 if (r->sepfile) {
3711                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
3712                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
3713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
3714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
3715                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
3716                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
3717                         }
3718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
3719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
3720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
3721                 }
3722                 if (r->printprocessor) {
3723                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3724                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
3725                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
3726                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
3727                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
3728                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
3729                         }
3730                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
3731                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
3732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
3733                 }
3734                 if (r->datatype) {
3735                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
3736                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
3737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
3738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
3739                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
3740                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
3741                         }
3742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
3743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
3744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
3745                 }
3746                 if (r->parameters) {
3747                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3748                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3749                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
3750                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
3751                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
3752                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
3753                         }
3754                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
3755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
3756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3757                 }
3758                 if (r->secdesc) {
3759                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3760                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3761                         {
3762                                 struct ndr_pull *_ndr_secdesc;
3763                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3764                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3765                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3766                         }
3767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3768                 }
3769         }
3770         return NDR_ERR_SUCCESS;
3771 }
3772
3773 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
3774 {
3775         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
3776         ndr->depth++;
3777         ndr_print_ptr(ndr, "servername", r->servername);
3778         ndr->depth++;
3779         if (r->servername) {
3780                 ndr_print_string(ndr, "servername", r->servername);
3781         }
3782         ndr->depth--;
3783         ndr_print_ptr(ndr, "printername", r->printername);
3784         ndr->depth++;
3785         if (r->printername) {
3786                 ndr_print_string(ndr, "printername", r->printername);
3787         }
3788         ndr->depth--;
3789         ndr_print_ptr(ndr, "sharename", r->sharename);
3790         ndr->depth++;
3791         if (r->sharename) {
3792                 ndr_print_string(ndr, "sharename", r->sharename);
3793         }
3794         ndr->depth--;
3795         ndr_print_ptr(ndr, "portname", r->portname);
3796         ndr->depth++;
3797         if (r->portname) {
3798                 ndr_print_string(ndr, "portname", r->portname);
3799         }
3800         ndr->depth--;
3801         ndr_print_ptr(ndr, "drivername", r->drivername);
3802         ndr->depth++;
3803         if (r->drivername) {
3804                 ndr_print_string(ndr, "drivername", r->drivername);
3805         }
3806         ndr->depth--;
3807         ndr_print_ptr(ndr, "comment", r->comment);
3808         ndr->depth++;
3809         if (r->comment) {
3810                 ndr_print_string(ndr, "comment", r->comment);
3811         }
3812         ndr->depth--;
3813         ndr_print_ptr(ndr, "location", r->location);
3814         ndr->depth++;
3815         if (r->location) {
3816                 ndr_print_string(ndr, "location", r->location);
3817         }
3818         ndr->depth--;
3819         ndr_print_ptr(ndr, "devmode", r->devmode);
3820         ndr->depth++;
3821         if (r->devmode) {
3822                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3823         }
3824         ndr->depth--;
3825         ndr_print_ptr(ndr, "sepfile", r->sepfile);
3826         ndr->depth++;
3827         if (r->sepfile) {
3828                 ndr_print_string(ndr, "sepfile", r->sepfile);
3829         }
3830         ndr->depth--;
3831         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
3832         ndr->depth++;
3833         if (r->printprocessor) {
3834                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
3835         }
3836         ndr->depth--;
3837         ndr_print_ptr(ndr, "datatype", r->datatype);
3838         ndr->depth++;
3839         if (r->datatype) {
3840                 ndr_print_string(ndr, "datatype", r->datatype);
3841         }
3842         ndr->depth--;
3843         ndr_print_ptr(ndr, "parameters", r->parameters);
3844         ndr->depth++;
3845         if (r->parameters) {
3846                 ndr_print_string(ndr, "parameters", r->parameters);
3847         }
3848         ndr->depth--;
3849         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3850         ndr->depth++;
3851         if (r->secdesc) {
3852                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3853         }
3854         ndr->depth--;
3855         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
3856         ndr_print_uint32(ndr, "priority", r->priority);
3857         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
3858         ndr_print_uint32(ndr, "starttime", r->starttime);
3859         ndr_print_uint32(ndr, "untiltime", r->untiltime);
3860         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
3861         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3862         ndr_print_uint32(ndr, "averageppm", r->averageppm);
3863         ndr->depth--;
3864 }
3865
3866 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
3867 {
3868         if (ndr_flags & NDR_SCALARS) {
3869                 NDR_CHECK(ndr_push_align(ndr, 4));
3870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3871         }
3872         if (ndr_flags & NDR_BUFFERS) {
3873                 if (r->secdesc) {
3874                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3875                 }
3876         }
3877         return NDR_ERR_SUCCESS;
3878 }
3879
3880 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
3881 {
3882         uint32_t _ptr_secdesc;
3883         TALLOC_CTX *_mem_save_secdesc_0;
3884         if (ndr_flags & NDR_SCALARS) {
3885                 NDR_CHECK(ndr_pull_align(ndr, 4));
3886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3887                 if (_ptr_secdesc) {
3888                         NDR_PULL_ALLOC(ndr, r->secdesc);
3889                 } else {
3890                         r->secdesc = NULL;
3891                 }
3892         }
3893         if (ndr_flags & NDR_BUFFERS) {
3894                 if (r->secdesc) {
3895                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3896                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3897                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3899                 }
3900         }
3901         return NDR_ERR_SUCCESS;
3902 }
3903
3904 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
3905 {
3906         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
3907         ndr->depth++;
3908         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3909         ndr->depth++;
3910         if (r->secdesc) {
3911                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3912         }
3913         ndr->depth--;
3914         ndr->depth--;
3915 }
3916
3917 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
3918 {
3919         if (ndr_flags & NDR_SCALARS) {
3920                 NDR_CHECK(ndr_push_align(ndr, 4));
3921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3923                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3924         }
3925         if (ndr_flags & NDR_BUFFERS) {
3926                 if (r->printername) {
3927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3931                 }
3932                 if (r->servername) {
3933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3937                 }
3938         }
3939         return NDR_ERR_SUCCESS;
3940 }
3941
3942 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
3943 {
3944         uint32_t _ptr_printername;
3945         TALLOC_CTX *_mem_save_printername_0;
3946         uint32_t _ptr_servername;
3947         TALLOC_CTX *_mem_save_servername_0;
3948         if (ndr_flags & NDR_SCALARS) {
3949                 NDR_CHECK(ndr_pull_align(ndr, 4));
3950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3951                 if (_ptr_printername) {
3952                         NDR_PULL_ALLOC(ndr, r->printername);
3953                 } else {
3954                         r->printername = NULL;
3955                 }
3956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3957                 if (_ptr_servername) {
3958                         NDR_PULL_ALLOC(ndr, r->servername);
3959                 } else {
3960                         r->servername = NULL;
3961                 }
3962                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3963         }
3964         if (ndr_flags & NDR_BUFFERS) {
3965                 if (r->printername) {
3966                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3967                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3970                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3972                         }
3973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3976                 }
3977                 if (r->servername) {
3978                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3979                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3982                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3984                         }
3985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3988                 }
3989         }
3990         return NDR_ERR_SUCCESS;
3991 }
3992
3993 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
3994 {
3995         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
3996         ndr->depth++;
3997         ndr_print_ptr(ndr, "printername", r->printername);
3998         ndr->depth++;
3999         if (r->printername) {
4000                 ndr_print_string(ndr, "printername", r->printername);
4001         }
4002         ndr->depth--;
4003         ndr_print_ptr(ndr, "servername", r->servername);
4004         ndr->depth++;
4005         if (r->servername) {
4006                 ndr_print_string(ndr, "servername", r->servername);
4007         }
4008         ndr->depth--;
4009         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4010         ndr->depth--;
4011 }
4012
4013 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
4014 {
4015         if (ndr_flags & NDR_SCALARS) {
4016                 NDR_CHECK(ndr_push_align(ndr, 4));
4017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
4018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
4019                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
4020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
4021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
4022         }
4023         if (ndr_flags & NDR_BUFFERS) {
4024                 if (r->printername) {
4025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4029                 }
4030                 if (r->portname) {
4031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4035                 }
4036         }
4037         return NDR_ERR_SUCCESS;
4038 }
4039
4040 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
4041 {
4042         uint32_t _ptr_printername;
4043         TALLOC_CTX *_mem_save_printername_0;
4044         uint32_t _ptr_portname;
4045         TALLOC_CTX *_mem_save_portname_0;
4046         if (ndr_flags & NDR_SCALARS) {
4047                 NDR_CHECK(ndr_pull_align(ndr, 4));
4048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4049                 if (_ptr_printername) {
4050                         NDR_PULL_ALLOC(ndr, r->printername);
4051                 } else {
4052                         r->printername = NULL;
4053                 }
4054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
4055                 if (_ptr_portname) {
4056                         NDR_PULL_ALLOC(ndr, r->portname);
4057                 } else {
4058                         r->portname = NULL;
4059                 }
4060                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
4061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
4062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
4063         }
4064         if (ndr_flags & NDR_BUFFERS) {
4065                 if (r->printername) {
4066                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4067                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4070                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4071                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
4072                         }
4073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4076                 }
4077                 if (r->portname) {
4078                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
4079                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
4080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
4081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
4082                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
4083                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
4084                         }
4085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
4086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
4087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
4096         ndr->depth++;
4097         ndr_print_ptr(ndr, "printername", r->printername);
4098         ndr->depth++;
4099         if (r->printername) {
4100                 ndr_print_string(ndr, "printername", r->printername);
4101         }
4102         ndr->depth--;
4103         ndr_print_ptr(ndr, "portname", r->portname);
4104         ndr->depth++;
4105         if (r->portname) {
4106                 ndr_print_string(ndr, "portname", r->portname);
4107         }
4108         ndr->depth--;
4109         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4110         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
4111         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
4112         ndr->depth--;
4113 }
4114
4115 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
4116 {
4117         if (ndr_flags & NDR_SCALARS) {
4118                 NDR_CHECK(ndr_push_align(ndr, 4));
4119                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
4120         }
4121         if (ndr_flags & NDR_BUFFERS) {
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
4127 {
4128         if (ndr_flags & NDR_SCALARS) {
4129                 NDR_CHECK(ndr_pull_align(ndr, 4));
4130                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
4131         }
4132         if (ndr_flags & NDR_BUFFERS) {
4133         }
4134         return NDR_ERR_SUCCESS;
4135 }
4136
4137 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
4138 {
4139         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
4140         ndr->depth++;
4141         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
4142         ndr->depth--;
4143 }
4144
4145 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
4146 {
4147         if (ndr_flags & NDR_SCALARS) {
4148                 NDR_CHECK(ndr_push_align(ndr, 4));
4149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
4150                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
4151         }
4152         if (ndr_flags & NDR_BUFFERS) {
4153                 if (r->guid) {
4154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4158                 }
4159         }
4160         return NDR_ERR_SUCCESS;
4161 }
4162
4163 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
4164 {
4165         uint32_t _ptr_guid;
4166         TALLOC_CTX *_mem_save_guid_0;
4167         if (ndr_flags & NDR_SCALARS) {
4168                 NDR_CHECK(ndr_pull_align(ndr, 4));
4169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
4170                 if (_ptr_guid) {
4171                         NDR_PULL_ALLOC(ndr, r->guid);
4172                 } else {
4173                         r->guid = NULL;
4174                 }
4175                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
4176         }
4177         if (ndr_flags & NDR_BUFFERS) {
4178                 if (r->guid) {
4179                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4180                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
4181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
4182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
4183                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
4184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
4185                         }
4186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
4187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
4188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
4189                 }
4190         }
4191         return NDR_ERR_SUCCESS;
4192 }
4193
4194 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
4195 {
4196         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
4197         ndr->depth++;
4198         ndr_print_ptr(ndr, "guid", r->guid);
4199         ndr->depth++;
4200         if (r->guid) {
4201                 ndr_print_string(ndr, "guid", r->guid);
4202         }
4203         ndr->depth--;
4204         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
4205         ndr->depth--;
4206 }
4207
4208 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
4209 {
4210         if (ndr_flags & NDR_SCALARS) {
4211                 int level = ndr_push_get_switch_value(ndr, r);
4212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4213                 switch (level) {
4214                         case 0: {
4215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4216                         break; }
4217
4218                         case 1: {
4219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4220                         break; }
4221
4222                         case 2: {
4223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4224                         break; }
4225
4226                         case 3: {
4227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4228                         break; }
4229
4230                         case 4: {
4231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
4232                         break; }
4233
4234                         case 5: {
4235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
4236                         break; }
4237
4238                         case 6: {
4239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
4240                         break; }
4241
4242                         case 7: {
4243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
4244                         break; }
4245
4246                         case 8: {
4247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
4248                         break; }
4249
4250                         case 9: {
4251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
4252                         break; }
4253
4254                         default: {
4255                         break; }
4256
4257                 }
4258         }
4259         if (ndr_flags & NDR_BUFFERS) {
4260                 int level = ndr_push_get_switch_value(ndr, r);
4261                 switch (level) {
4262                         case 0:
4263                                 if (r->info0) {
4264                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4265                                 }
4266                         break;
4267
4268                         case 1:
4269                                 if (r->info1) {
4270                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4271                                 }
4272                         break;
4273
4274                         case 2:
4275                                 if (r->info2) {
4276                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4277                                 }
4278                         break;
4279
4280                         case 3:
4281                                 if (r->info3) {
4282                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4283                                 }
4284                         break;
4285
4286                         case 4:
4287                                 if (r->info4) {
4288                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4289                                 }
4290                         break;
4291
4292                         case 5:
4293                                 if (r->info5) {
4294                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4295                                 }
4296                         break;
4297
4298                         case 6:
4299                                 if (r->info6) {
4300                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4301                                 }
4302                         break;
4303
4304                         case 7:
4305                                 if (r->info7) {
4306                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4307                                 }
4308                         break;
4309
4310                         case 8:
4311                                 if (r->info8) {
4312                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4313                                 }
4314                         break;
4315
4316                         case 9:
4317                                 if (r->info9) {
4318                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4319                                 }
4320                         break;
4321
4322                         default:
4323                         break;
4324
4325                 }
4326         }
4327         return NDR_ERR_SUCCESS;
4328 }
4329
4330 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
4331 {
4332         int level;
4333         uint32_t _level;
4334         TALLOC_CTX *_mem_save_info0_0;
4335         TALLOC_CTX *_mem_save_info1_0;
4336         TALLOC_CTX *_mem_save_info2_0;
4337         TALLOC_CTX *_mem_save_info3_0;
4338         TALLOC_CTX *_mem_save_info4_0;
4339         TALLOC_CTX *_mem_save_info5_0;
4340         TALLOC_CTX *_mem_save_info6_0;
4341         TALLOC_CTX *_mem_save_info7_0;
4342         TALLOC_CTX *_mem_save_info8_0;
4343         TALLOC_CTX *_mem_save_info9_0;
4344         level = ndr_pull_get_switch_value(ndr, r);
4345         if (ndr_flags & NDR_SCALARS) {
4346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4347                 if (_level != level) {
4348                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4349                 }
4350                 switch (level) {
4351                         case 0: {
4352                                 uint32_t _ptr_info0;
4353                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4354                                 if (_ptr_info0) {
4355                                         NDR_PULL_ALLOC(ndr, r->info0);
4356                                 } else {
4357                                         r->info0 = NULL;
4358                                 }
4359                         break; }
4360
4361                         case 1: {
4362                                 uint32_t _ptr_info1;
4363                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4364                                 if (_ptr_info1) {
4365                                         NDR_PULL_ALLOC(ndr, r->info1);
4366                                 } else {
4367                                         r->info1 = NULL;
4368                                 }
4369                         break; }
4370
4371                         case 2: {
4372                                 uint32_t _ptr_info2;
4373                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4374                                 if (_ptr_info2) {
4375                                         NDR_PULL_ALLOC(ndr, r->info2);
4376                                 } else {
4377                                         r->info2 = NULL;
4378                                 }
4379                         break; }
4380
4381                         case 3: {
4382                                 uint32_t _ptr_info3;
4383                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4384                                 if (_ptr_info3) {
4385                                         NDR_PULL_ALLOC(ndr, r->info3);
4386                                 } else {
4387                                         r->info3 = NULL;
4388                                 }
4389                         break; }
4390
4391                         case 4: {
4392                                 uint32_t _ptr_info4;
4393                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
4394                                 if (_ptr_info4) {
4395                                         NDR_PULL_ALLOC(ndr, r->info4);
4396                                 } else {
4397                                         r->info4 = NULL;
4398                                 }
4399                         break; }
4400
4401                         case 5: {
4402                                 uint32_t _ptr_info5;
4403                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
4404                                 if (_ptr_info5) {
4405                                         NDR_PULL_ALLOC(ndr, r->info5);
4406                                 } else {
4407                                         r->info5 = NULL;
4408                                 }
4409                         break; }
4410
4411                         case 6: {
4412                                 uint32_t _ptr_info6;
4413                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
4414                                 if (_ptr_info6) {
4415                                         NDR_PULL_ALLOC(ndr, r->info6);
4416                                 } else {
4417                                         r->info6 = NULL;
4418                                 }
4419                         break; }
4420
4421                         case 7: {
4422                                 uint32_t _ptr_info7;
4423                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
4424                                 if (_ptr_info7) {
4425                                         NDR_PULL_ALLOC(ndr, r->info7);
4426                                 } else {
4427                                         r->info7 = NULL;
4428                                 }
4429                         break; }
4430
4431                         case 8: {
4432                                 uint32_t _ptr_info8;
4433                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
4434                                 if (_ptr_info8) {
4435                                         NDR_PULL_ALLOC(ndr, r->info8);
4436                                 } else {
4437                                         r->info8 = NULL;
4438                                 }
4439                         break; }
4440
4441                         case 9: {
4442                                 uint32_t _ptr_info9;
4443                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
4444                                 if (_ptr_info9) {
4445                                         NDR_PULL_ALLOC(ndr, r->info9);
4446                                 } else {
4447                                         r->info9 = NULL;
4448                                 }
4449                         break; }
4450
4451                         default: {
4452                         break; }
4453
4454                 }
4455         }
4456         if (ndr_flags & NDR_BUFFERS) {
4457                 switch (level) {
4458                         case 0:
4459                                 if (r->info0) {
4460                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4461                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4462                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4463                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4464                                 }
4465                         break;
4466
4467                         case 1:
4468                                 if (r->info1) {
4469                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4470                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4471                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4472                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4473                                 }
4474                         break;
4475
4476                         case 2:
4477                                 if (r->info2) {
4478                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4479                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4480                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4481                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4482                                 }
4483                         break;
4484
4485                         case 3:
4486                                 if (r->info3) {
4487                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4488                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4489                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4490                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4491                                 }
4492                         break;
4493
4494                         case 4:
4495                                 if (r->info4) {
4496                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
4497                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
4498                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4499                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
4500                                 }
4501                         break;
4502
4503                         case 5:
4504                                 if (r->info5) {
4505                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
4506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
4507                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
4509                                 }
4510                         break;
4511
4512                         case 6:
4513                                 if (r->info6) {
4514                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
4515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
4516                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
4518                                 }
4519                         break;
4520
4521                         case 7:
4522                                 if (r->info7) {
4523                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
4524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
4525                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
4527                                 }
4528                         break;
4529
4530                         case 8:
4531                                 if (r->info8) {
4532                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
4534                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
4536                                 }
4537                         break;
4538
4539                         case 9:
4540                                 if (r->info9) {
4541                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
4542                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
4543                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
4545                                 }
4546                         break;
4547
4548                         default:
4549                         break;
4550
4551                 }
4552         }
4553         return NDR_ERR_SUCCESS;
4554 }
4555
4556 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
4557 {
4558         int level;
4559         level = ndr_print_get_switch_value(ndr, r);
4560         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
4561         switch (level) {
4562                 case 0:
4563                         ndr_print_ptr(ndr, "info0", r->info0);
4564                         ndr->depth++;
4565                         if (r->info0) {
4566                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
4567                         }
4568                         ndr->depth--;
4569                 break;
4570
4571                 case 1:
4572                         ndr_print_ptr(ndr, "info1", r->info1);
4573                         ndr->depth++;
4574                         if (r->info1) {
4575                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
4576                         }
4577                         ndr->depth--;
4578                 break;
4579
4580                 case 2:
4581                         ndr_print_ptr(ndr, "info2", r->info2);
4582                         ndr->depth++;
4583                         if (r->info2) {
4584                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
4585                         }
4586                         ndr->depth--;
4587                 break;
4588
4589                 case 3:
4590                         ndr_print_ptr(ndr, "info3", r->info3);
4591                         ndr->depth++;
4592                         if (r->info3) {
4593                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
4594                         }
4595                         ndr->depth--;
4596                 break;
4597
4598                 case 4:
4599                         ndr_print_ptr(ndr, "info4", r->info4);
4600                         ndr->depth++;
4601                         if (r->info4) {
4602                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
4603                         }
4604                         ndr->depth--;
4605                 break;
4606
4607                 case 5:
4608                         ndr_print_ptr(ndr, "info5", r->info5);
4609                         ndr->depth++;
4610                         if (r->info5) {
4611                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
4612                         }
4613                         ndr->depth--;
4614                 break;
4615
4616                 case 6:
4617                         ndr_print_ptr(ndr, "info6", r->info6);
4618                         ndr->depth++;
4619                         if (r->info6) {
4620                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
4621                         }
4622                         ndr->depth--;
4623                 break;
4624
4625                 case 7:
4626                         ndr_print_ptr(ndr, "info7", r->info7);
4627                         ndr->depth++;
4628                         if (r->info7) {
4629                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
4630                         }
4631                         ndr->depth--;
4632                 break;
4633
4634                 case 8:
4635                         ndr_print_ptr(ndr, "info8", r->info8);
4636                         ndr->depth++;
4637                         if (r->info8) {
4638                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
4639                         }
4640                         ndr->depth--;
4641                 break;
4642
4643                 case 9:
4644                         ndr_print_ptr(ndr, "info9", r->info9);
4645                         ndr->depth++;
4646                         if (r->info9) {
4647                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
4648                         }
4649                         ndr->depth--;
4650                 break;
4651
4652                 default:
4653                 break;
4654
4655         }
4656 }
4657
4658 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
4659 {
4660         if (ndr_flags & NDR_SCALARS) {
4661                 NDR_CHECK(ndr_push_align(ndr, 4));
4662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
4664                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4665         }
4666         if (ndr_flags & NDR_BUFFERS) {
4667                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4668         }
4669         return NDR_ERR_SUCCESS;
4670 }
4671
4672 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
4673 {
4674         if (ndr_flags & NDR_SCALARS) {
4675                 NDR_CHECK(ndr_pull_align(ndr, 4));
4676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4677                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
4678                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4679         }
4680         if (ndr_flags & NDR_BUFFERS) {
4681                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4682         }
4683         return NDR_ERR_SUCCESS;
4684 }
4685
4686 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
4687 {
4688         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
4689         ndr->depth++;
4690         ndr_print_uint32(ndr, "level", r->level);
4691         ndr_print_set_switch_value(ndr, &r->info, r->level);
4692         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
4693         ndr->depth--;
4694 }
4695
4696 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
4697 {
4698         if (ndr_flags & NDR_SCALARS) {
4699                 NDR_CHECK(ndr_push_align(ndr, 4));
4700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
4701                 {
4702                         uint32_t _flags_save_string_array = ndr->flags;
4703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4704                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
4705                         ndr->flags = _flags_save_string_array;
4706                 }
4707         }
4708         if (ndr_flags & NDR_BUFFERS) {
4709         }
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
4714 {
4715         if (ndr_flags & NDR_SCALARS) {
4716                 NDR_CHECK(ndr_pull_align(ndr, 4));
4717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
4718                 {
4719                         uint32_t _flags_save_string_array = ndr->flags;
4720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4721                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
4722                         ndr->flags = _flags_save_string_array;
4723                 }
4724         }
4725         if (ndr_flags & NDR_BUFFERS) {
4726         }
4727         return NDR_ERR_SUCCESS;
4728 }
4729
4730 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
4731 {
4732         ndr_print_struct(ndr, name, "spoolss_StringArray");
4733         ndr->depth++;
4734         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
4735         ndr_print_string_array(ndr, "string", r->string);
4736         ndr->depth--;
4737 }
4738
4739 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
4740 {
4741         if (ndr_flags & NDR_SCALARS) {
4742                 NDR_CHECK(ndr_push_align(ndr, 4));
4743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4744         }
4745         if (ndr_flags & NDR_BUFFERS) {
4746                 if (r->driver_name) {
4747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4751                 }
4752         }
4753         return NDR_ERR_SUCCESS;
4754 }
4755
4756 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
4757 {
4758         uint32_t _ptr_driver_name;
4759         TALLOC_CTX *_mem_save_driver_name_0;
4760         if (ndr_flags & NDR_SCALARS) {
4761                 NDR_CHECK(ndr_pull_align(ndr, 4));
4762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4763                 if (_ptr_driver_name) {
4764                         NDR_PULL_ALLOC(ndr, r->driver_name);
4765                 } else {
4766                         r->driver_name = NULL;
4767                 }
4768         }
4769         if (ndr_flags & NDR_BUFFERS) {
4770                 if (r->driver_name) {
4771                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4772                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4775                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4776                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4777                         }
4778                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4779                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4781                 }
4782         }
4783         return NDR_ERR_SUCCESS;
4784 }
4785
4786 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
4787 {
4788         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
4789         ndr->depth++;
4790         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4791         ndr->depth++;
4792         if (r->driver_name) {
4793                 ndr_print_string(ndr, "driver_name", r->driver_name);
4794         }
4795         ndr->depth--;
4796         ndr->depth--;
4797 }
4798
4799 static enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
4800 {
4801         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4802         return NDR_ERR_SUCCESS;
4803 }
4804
4805 static enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
4806 {
4807         uint32_t v;
4808         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4809         *r = v;
4810         return NDR_ERR_SUCCESS;
4811 }
4812
4813 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
4814 {
4815         const char *val = NULL;
4816
4817         switch (r) {
4818                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
4819                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
4820                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
4821                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
4822         }
4823         ndr_print_enum(ndr, name, "ENUM", val, r);
4824 }
4825
4826 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
4827 {
4828         if (ndr_flags & NDR_SCALARS) {
4829                 NDR_CHECK(ndr_push_align(ndr, 4));
4830                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4831                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
4833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
4834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
4835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
4836         }
4837         if (ndr_flags & NDR_BUFFERS) {
4838                 if (r->driver_name) {
4839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4843                 }
4844                 if (r->architecture) {
4845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4848                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4849                 }
4850                 if (r->driver_path) {
4851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4854                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4855                 }
4856                 if (r->data_file) {
4857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4861                 }
4862                 if (r->config_file) {
4863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4867                 }
4868         }
4869         return NDR_ERR_SUCCESS;
4870 }
4871
4872 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
4873 {
4874         uint32_t _ptr_driver_name;
4875         TALLOC_CTX *_mem_save_driver_name_0;
4876         uint32_t _ptr_architecture;
4877         TALLOC_CTX *_mem_save_architecture_0;
4878         uint32_t _ptr_driver_path;
4879         TALLOC_CTX *_mem_save_driver_path_0;
4880         uint32_t _ptr_data_file;
4881         TALLOC_CTX *_mem_save_data_file_0;
4882         uint32_t _ptr_config_file;
4883         TALLOC_CTX *_mem_save_config_file_0;
4884         if (ndr_flags & NDR_SCALARS) {
4885                 NDR_CHECK(ndr_pull_align(ndr, 4));
4886                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4887                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4888                 if (_ptr_driver_name) {
4889                         NDR_PULL_ALLOC(ndr, r->driver_name);
4890                 } else {
4891                         r->driver_name = NULL;
4892                 }
4893                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4894                 if (_ptr_architecture) {
4895                         NDR_PULL_ALLOC(ndr, r->architecture);
4896                 } else {
4897                         r->architecture = NULL;
4898                 }
4899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4900                 if (_ptr_driver_path) {
4901                         NDR_PULL_ALLOC(ndr, r->driver_path);
4902                 } else {
4903                         r->driver_path = NULL;
4904                 }
4905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4906                 if (_ptr_data_file) {
4907                         NDR_PULL_ALLOC(ndr, r->data_file);
4908                 } else {
4909                         r->data_file = NULL;
4910                 }
4911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4912                 if (_ptr_config_file) {
4913                         NDR_PULL_ALLOC(ndr, r->config_file);
4914                 } else {
4915                         r->config_file = NULL;
4916                 }
4917         }
4918         if (ndr_flags & NDR_BUFFERS) {
4919                 if (r->driver_name) {
4920                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4921                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4922                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4923                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4924                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4925                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4926                         }
4927                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4930                 }
4931                 if (r->architecture) {
4932                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4933                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4934                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
4935                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
4936                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
4937                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
4938                         }
4939                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
4940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
4941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4942                 }
4943                 if (r->driver_path) {
4944                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4945                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
4947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
4948                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
4949                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
4950                         }
4951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
4952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
4953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4954                 }
4955                 if (r->data_file) {
4956                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4957                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
4959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
4960                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
4961                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
4962                         }
4963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
4964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
4965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4966                 }
4967                 if (r->config_file) {
4968                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4969                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
4971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
4972                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
4973                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
4974                         }
4975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
4976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
4977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4978                 }
4979         }
4980         return NDR_ERR_SUCCESS;
4981 }
4982
4983 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
4984 {
4985         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
4986         ndr->depth++;
4987         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4988         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4989         ndr->depth++;
4990         if (r->driver_name) {
4991                 ndr_print_string(ndr, "driver_name", r->driver_name);
4992         }
4993         ndr->depth--;
4994         ndr_print_ptr(ndr, "architecture", r->architecture);
4995         ndr->depth++;
4996         if (r->architecture) {
4997                 ndr_print_string(ndr, "architecture", r->architecture);
4998         }
4999         ndr->depth--;
5000         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5001         ndr->depth++;
5002         if (r->driver_path) {
5003                 ndr_print_string(ndr, "driver_path", r->driver_path);
5004         }
5005         ndr->depth--;
5006         ndr_print_ptr(ndr, "data_file", r->data_file);
5007         ndr->depth++;
5008         if (r->data_file) {
5009                 ndr_print_string(ndr, "data_file", r->data_file);
5010         }
5011         ndr->depth--;
5012         ndr_print_ptr(ndr, "config_file", r->config_file);
5013         ndr->depth++;
5014         if (r->config_file) {
5015                 ndr_print_string(ndr, "config_file", r->config_file);
5016         }
5017         ndr->depth--;
5018         ndr->depth--;
5019 }
5020
5021 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
5022 {
5023         if (ndr_flags & NDR_SCALARS) {
5024                 NDR_CHECK(ndr_push_align(ndr, 4));
5025                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5026                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5036         }
5037         if (ndr_flags & NDR_BUFFERS) {
5038                 if (r->driver_name) {
5039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5042                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5043                 }
5044                 if (r->architecture) {
5045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5048                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5049                 }
5050                 if (r->driver_path) {
5051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5054                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5055                 }
5056                 if (r->data_file) {
5057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5060                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5061                 }
5062                 if (r->config_file) {
5063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5066                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5067                 }
5068                 if (r->help_file) {
5069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5072                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5073                 }
5074                 if (r->monitor_name) {
5075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5078                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5079                 }
5080                 if (r->default_datatype) {
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5085                 }
5086                 if (r->dependent_files) {
5087                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5088                 }
5089         }
5090         return NDR_ERR_SUCCESS;
5091 }
5092
5093 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
5094 {
5095         uint32_t _ptr_driver_name;
5096         TALLOC_CTX *_mem_save_driver_name_0;
5097         uint32_t _ptr_architecture;
5098         TALLOC_CTX *_mem_save_architecture_0;
5099         uint32_t _ptr_driver_path;
5100         TALLOC_CTX *_mem_save_driver_path_0;
5101         uint32_t _ptr_data_file;
5102         TALLOC_CTX *_mem_save_data_file_0;
5103         uint32_t _ptr_config_file;
5104         TALLOC_CTX *_mem_save_config_file_0;
5105         uint32_t _ptr_help_file;
5106         TALLOC_CTX *_mem_save_help_file_0;
5107         uint32_t _ptr_monitor_name;
5108         TALLOC_CTX *_mem_save_monitor_name_0;
5109         uint32_t _ptr_default_datatype;
5110         TALLOC_CTX *_mem_save_default_datatype_0;
5111         uint32_t _ptr_dependent_files;
5112         TALLOC_CTX *_mem_save_dependent_files_0;
5113         if (ndr_flags & NDR_SCALARS) {
5114                 NDR_CHECK(ndr_pull_align(ndr, 4));
5115                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5117                 if (_ptr_driver_name) {
5118                         NDR_PULL_ALLOC(ndr, r->driver_name);
5119                 } else {
5120                         r->driver_name = NULL;
5121                 }
5122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5123                 if (_ptr_architecture) {
5124                         NDR_PULL_ALLOC(ndr, r->architecture);
5125                 } else {
5126                         r->architecture = NULL;
5127                 }
5128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5129                 if (_ptr_driver_path) {
5130                         NDR_PULL_ALLOC(ndr, r->driver_path);
5131                 } else {
5132                         r->driver_path = NULL;
5133                 }
5134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5135                 if (_ptr_data_file) {
5136                         NDR_PULL_ALLOC(ndr, r->data_file);
5137                 } else {
5138                         r->data_file = NULL;
5139                 }
5140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5141                 if (_ptr_config_file) {
5142                         NDR_PULL_ALLOC(ndr, r->config_file);
5143                 } else {
5144                         r->config_file = NULL;
5145                 }
5146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5147                 if (_ptr_help_file) {
5148                         NDR_PULL_ALLOC(ndr, r->help_file);
5149                 } else {
5150                         r->help_file = NULL;
5151                 }
5152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5153                 if (_ptr_monitor_name) {
5154                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5155                 } else {
5156                         r->monitor_name = NULL;
5157                 }
5158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5159                 if (_ptr_default_datatype) {
5160                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5161                 } else {
5162                         r->default_datatype = NULL;
5163                 }
5164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5166                 if (_ptr_dependent_files) {
5167                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5168                 } else {
5169                         r->dependent_files = NULL;
5170                 }
5171         }
5172         if (ndr_flags & NDR_BUFFERS) {
5173                 if (r->driver_name) {
5174                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5175                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5178                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5179                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5180                         }
5181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5184                 }
5185                 if (r->architecture) {
5186                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5187                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5188                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5189                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5190                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5191                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5192                         }
5193                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5194                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5196                 }
5197                 if (r->driver_path) {
5198                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5199                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5201                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5202                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5203                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5204                         }
5205                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5206                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5208                 }
5209                 if (r->data_file) {
5210                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5211                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5212                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5213                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5214                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5215                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5216                         }
5217                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5218                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5220                 }
5221                 if (r->config_file) {
5222                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5223                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5224                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5225                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5226                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5227                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5228                         }
5229                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5230                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5232                 }
5233                 if (r->help_file) {
5234                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5235                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5236                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5237                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5238                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5239                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5240                         }
5241                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5242                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5244                 }
5245                 if (r->monitor_name) {
5246                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5247                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5249                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5250                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5251                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5252                         }
5253                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5254                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5256                 }
5257                 if (r->default_datatype) {
5258                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5259                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5260                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5261                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5262                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5263                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5264                         }
5265                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5266                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5268                 }
5269                 if (r->dependent_files) {
5270                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5271                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5272                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5274                 }
5275         }
5276         return NDR_ERR_SUCCESS;
5277 }
5278
5279 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
5280 {
5281         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
5282         ndr->depth++;
5283         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5284         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5285         ndr->depth++;
5286         if (r->driver_name) {
5287                 ndr_print_string(ndr, "driver_name", r->driver_name);
5288         }
5289         ndr->depth--;
5290         ndr_print_ptr(ndr, "architecture", r->architecture);
5291         ndr->depth++;
5292         if (r->architecture) {
5293                 ndr_print_string(ndr, "architecture", r->architecture);
5294         }
5295         ndr->depth--;
5296         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5297         ndr->depth++;
5298         if (r->driver_path) {
5299                 ndr_print_string(ndr, "driver_path", r->driver_path);
5300         }
5301         ndr->depth--;
5302         ndr_print_ptr(ndr, "data_file", r->data_file);
5303         ndr->depth++;
5304         if (r->data_file) {
5305                 ndr_print_string(ndr, "data_file", r->data_file);
5306         }
5307         ndr->depth--;
5308         ndr_print_ptr(ndr, "config_file", r->config_file);
5309         ndr->depth++;
5310         if (r->config_file) {
5311                 ndr_print_string(ndr, "config_file", r->config_file);
5312         }
5313         ndr->depth--;
5314         ndr_print_ptr(ndr, "help_file", r->help_file);
5315         ndr->depth++;
5316         if (r->help_file) {
5317                 ndr_print_string(ndr, "help_file", r->help_file);
5318         }
5319         ndr->depth--;
5320         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5321         ndr->depth++;
5322         if (r->monitor_name) {
5323                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5324         }
5325         ndr->depth--;
5326         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5327         ndr->depth++;
5328         if (r->default_datatype) {
5329                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5330         }
5331         ndr->depth--;
5332         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
5333         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5334         ndr->depth++;
5335         if (r->dependent_files) {
5336                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5337         }
5338         ndr->depth--;
5339         ndr->depth--;
5340 }
5341
5342 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
5343 {
5344         if (ndr_flags & NDR_SCALARS) {
5345                 NDR_CHECK(ndr_push_align(ndr, 4));
5346                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5359         }
5360         if (ndr_flags & NDR_BUFFERS) {
5361                 if (r->driver_name) {
5362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5365                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5366                 }
5367                 if (r->architecture) {
5368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5371                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5372                 }
5373                 if (r->driver_path) {
5374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5378                 }
5379                 if (r->data_file) {
5380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5383                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5384                 }
5385                 if (r->config_file) {
5386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5390                 }
5391                 if (r->help_file) {
5392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5394                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5396                 }
5397                 if (r->monitor_name) {
5398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5402                 }
5403                 if (r->default_datatype) {
5404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5408                 }
5409                 if (r->dependent_files) {
5410                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5411                 }
5412                 if (r->previous_names) {
5413                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5414                 }
5415         }
5416         return NDR_ERR_SUCCESS;
5417 }
5418
5419 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
5420 {
5421         uint32_t _ptr_driver_name;
5422         TALLOC_CTX *_mem_save_driver_name_0;
5423         uint32_t _ptr_architecture;
5424         TALLOC_CTX *_mem_save_architecture_0;
5425         uint32_t _ptr_driver_path;
5426         TALLOC_CTX *_mem_save_driver_path_0;
5427         uint32_t _ptr_data_file;
5428         TALLOC_CTX *_mem_save_data_file_0;
5429         uint32_t _ptr_config_file;
5430         TALLOC_CTX *_mem_save_config_file_0;
5431         uint32_t _ptr_help_file;
5432         TALLOC_CTX *_mem_save_help_file_0;
5433         uint32_t _ptr_monitor_name;
5434         TALLOC_CTX *_mem_save_monitor_name_0;
5435         uint32_t _ptr_default_datatype;
5436         TALLOC_CTX *_mem_save_default_datatype_0;
5437         uint32_t _ptr_dependent_files;
5438         TALLOC_CTX *_mem_save_dependent_files_0;
5439         uint32_t _ptr_previous_names;
5440         TALLOC_CTX *_mem_save_previous_names_0;
5441         if (ndr_flags & NDR_SCALARS) {
5442                 NDR_CHECK(ndr_pull_align(ndr, 4));
5443                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5445                 if (_ptr_driver_name) {
5446                         NDR_PULL_ALLOC(ndr, r->driver_name);
5447                 } else {
5448                         r->driver_name = NULL;
5449                 }
5450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5451                 if (_ptr_architecture) {
5452                         NDR_PULL_ALLOC(ndr, r->architecture);
5453                 } else {
5454                         r->architecture = NULL;
5455                 }
5456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5457                 if (_ptr_driver_path) {
5458                         NDR_PULL_ALLOC(ndr, r->driver_path);
5459                 } else {
5460                         r->driver_path = NULL;
5461                 }
5462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5463                 if (_ptr_data_file) {
5464                         NDR_PULL_ALLOC(ndr, r->data_file);
5465                 } else {
5466                         r->data_file = NULL;
5467                 }
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5469                 if (_ptr_config_file) {
5470                         NDR_PULL_ALLOC(ndr, r->config_file);
5471                 } else {
5472                         r->config_file = NULL;
5473                 }
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5475                 if (_ptr_help_file) {
5476                         NDR_PULL_ALLOC(ndr, r->help_file);
5477                 } else {
5478                         r->help_file = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5481                 if (_ptr_monitor_name) {
5482                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5483                 } else {
5484                         r->monitor_name = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5487                 if (_ptr_default_datatype) {
5488                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5489                 } else {
5490                         r->default_datatype = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5494                 if (_ptr_dependent_files) {
5495                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5496                 } else {
5497                         r->dependent_files = NULL;
5498                 }
5499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5501                 if (_ptr_previous_names) {
5502                         NDR_PULL_ALLOC(ndr, r->previous_names);
5503                 } else {
5504                         r->previous_names = NULL;
5505                 }
5506         }
5507         if (ndr_flags & NDR_BUFFERS) {
5508                 if (r->driver_name) {
5509                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5510                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5511                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5512                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5513                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5514                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5515                         }
5516                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5517                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5519                 }
5520                 if (r->architecture) {
5521                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5522                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5523                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5524                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5525                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5526                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5527                         }
5528                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5531                 }
5532                 if (r->driver_path) {
5533                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5534                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5535                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5536                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5537                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5538                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5539                         }
5540                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5541                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5543                 }
5544                 if (r->data_file) {
5545                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5546                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5547                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5548                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5549                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5550                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5551                         }
5552                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5553                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5555                 }
5556                 if (r->config_file) {
5557                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5558                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5560                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5561                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5562                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5563                         }
5564                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5565                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5567                 }
5568                 if (r->help_file) {
5569                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5570                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5573                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5575                         }
5576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5579                 }
5580                 if (r->monitor_name) {
5581                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5582                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5585                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5586                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5587                         }
5588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5591                 }
5592                 if (r->default_datatype) {
5593                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5594                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5597                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5598                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5599                         }
5600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5603                 }
5604                 if (r->dependent_files) {
5605                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5606                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5607                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5609                 }
5610                 if (r->previous_names) {
5611                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5612                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
5613                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
5615                 }
5616         }
5617         return NDR_ERR_SUCCESS;
5618 }
5619
5620 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
5621 {
5622         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
5623         ndr->depth++;
5624         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5625         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5626         ndr->depth++;
5627         if (r->driver_name) {
5628                 ndr_print_string(ndr, "driver_name", r->driver_name);
5629         }
5630         ndr->depth--;
5631         ndr_print_ptr(ndr, "architecture", r->architecture);
5632         ndr->depth++;
5633         if (r->architecture) {
5634                 ndr_print_string(ndr, "architecture", r->architecture);
5635         }
5636         ndr->depth--;
5637         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5638         ndr->depth++;
5639         if (r->driver_path) {
5640                 ndr_print_string(ndr, "driver_path", r->driver_path);
5641         }
5642         ndr->depth--;
5643         ndr_print_ptr(ndr, "data_file", r->data_file);
5644         ndr->depth++;
5645         if (r->data_file) {
5646                 ndr_print_string(ndr, "data_file", r->data_file);
5647         }
5648         ndr->depth--;
5649         ndr_print_ptr(ndr, "config_file", r->config_file);
5650         ndr->depth++;
5651         if (r->config_file) {
5652                 ndr_print_string(ndr, "config_file", r->config_file);
5653         }
5654         ndr->depth--;
5655         ndr_print_ptr(ndr, "help_file", r->help_file);
5656         ndr->depth++;
5657         if (r->help_file) {
5658                 ndr_print_string(ndr, "help_file", r->help_file);
5659         }
5660         ndr->depth--;
5661         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5662         ndr->depth++;
5663         if (r->monitor_name) {
5664                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5665         }
5666         ndr->depth--;
5667         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5668         ndr->depth++;
5669         if (r->default_datatype) {
5670                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5671         }
5672         ndr->depth--;
5673         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
5674         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5675         ndr->depth++;
5676         if (r->dependent_files) {
5677                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5678         }
5679         ndr->depth--;
5680         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
5681         ndr_print_ptr(ndr, "previous_names", r->previous_names);
5682         ndr->depth++;
5683         if (r->previous_names) {
5684                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
5685         }
5686         ndr->depth--;
5687         ndr->depth--;
5688 }
5689
5690 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
5691 {
5692         if (ndr_flags & NDR_SCALARS) {
5693                 NDR_CHECK(ndr_push_align(ndr, 8));
5694                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5707                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
5708                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
5709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
5710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
5711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
5712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
5713         }
5714         if (ndr_flags & NDR_BUFFERS) {
5715                 if (r->driver_name) {
5716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5720                 }
5721                 if (r->architecture) {
5722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5726                 }
5727                 if (r->driver_path) {
5728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5732                 }
5733                 if (r->data_file) {
5734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5737                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5738                 }
5739                 if (r->config_file) {
5740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5744                 }
5745                 if (r->help_file) {
5746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5749                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5750                 }
5751                 if (r->monitor_name) {
5752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5756                 }
5757                 if (r->default_datatype) {
5758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5762                 }
5763                 if (r->dependent_files) {
5764                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5765                 }
5766                 if (r->previous_names) {
5767                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5768                 }
5769                 if (r->manufacturer_name) {
5770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5774                 }
5775                 if (r->manufacturer_url) {
5776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5778                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5780                 }
5781                 if (r->hardware_id) {
5782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5784                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5786                 }
5787                 if (r->provider) {
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5792                 }
5793         }
5794         return NDR_ERR_SUCCESS;
5795 }
5796
5797 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
5798 {
5799         uint32_t _ptr_driver_name;
5800         TALLOC_CTX *_mem_save_driver_name_0;
5801         uint32_t _ptr_architecture;
5802         TALLOC_CTX *_mem_save_architecture_0;
5803         uint32_t _ptr_driver_path;
5804         TALLOC_CTX *_mem_save_driver_path_0;
5805         uint32_t _ptr_data_file;
5806         TALLOC_CTX *_mem_save_data_file_0;
5807         uint32_t _ptr_config_file;
5808         TALLOC_CTX *_mem_save_config_file_0;
5809         uint32_t _ptr_help_file;
5810         TALLOC_CTX *_mem_save_help_file_0;
5811         uint32_t _ptr_monitor_name;
5812         TALLOC_CTX *_mem_save_monitor_name_0;
5813         uint32_t _ptr_default_datatype;
5814         TALLOC_CTX *_mem_save_default_datatype_0;
5815         uint32_t _ptr_dependent_files;
5816         TALLOC_CTX *_mem_save_dependent_files_0;
5817         uint32_t _ptr_previous_names;
5818         TALLOC_CTX *_mem_save_previous_names_0;
5819         uint32_t _ptr_manufacturer_name;
5820         TALLOC_CTX *_mem_save_manufacturer_name_0;
5821         uint32_t _ptr_manufacturer_url;
5822         TALLOC_CTX *_mem_save_manufacturer_url_0;
5823         uint32_t _ptr_hardware_id;
5824         TALLOC_CTX *_mem_save_hardware_id_0;
5825         uint32_t _ptr_provider;
5826         TALLOC_CTX *_mem_save_provider_0;
5827         if (ndr_flags & NDR_SCALARS) {
5828                 NDR_CHECK(ndr_pull_align(ndr, 8));
5829                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5831                 if (_ptr_driver_name) {
5832                         NDR_PULL_ALLOC(ndr, r->driver_name);
5833                 } else {
5834                         r->driver_name = NULL;
5835                 }
5836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5837                 if (_ptr_architecture) {
5838                         NDR_PULL_ALLOC(ndr, r->architecture);
5839                 } else {
5840                         r->architecture = NULL;
5841                 }
5842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5843                 if (_ptr_driver_path) {
5844                         NDR_PULL_ALLOC(ndr, r->driver_path);
5845                 } else {
5846                         r->driver_path = NULL;
5847                 }
5848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5849                 if (_ptr_data_file) {
5850                         NDR_PULL_ALLOC(ndr, r->data_file);
5851                 } else {
5852                         r->data_file = NULL;
5853                 }
5854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5855                 if (_ptr_config_file) {
5856                         NDR_PULL_ALLOC(ndr, r->config_file);
5857                 } else {
5858                         r->config_file = NULL;
5859                 }
5860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5861                 if (_ptr_help_file) {
5862                         NDR_PULL_ALLOC(ndr, r->help_file);
5863                 } else {
5864                         r->help_file = NULL;
5865                 }
5866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5867                 if (_ptr_monitor_name) {
5868                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5869                 } else {
5870                         r->monitor_name = NULL;
5871                 }
5872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5873                 if (_ptr_default_datatype) {
5874                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5875                 } else {
5876                         r->default_datatype = NULL;
5877                 }
5878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5880                 if (_ptr_dependent_files) {
5881                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5882                 } else {
5883                         r->dependent_files = NULL;
5884                 }
5885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5887                 if (_ptr_previous_names) {
5888                         NDR_PULL_ALLOC(ndr, r->previous_names);
5889                 } else {
5890                         r->previous_names = NULL;
5891                 }
5892                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
5893                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
5894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
5895                 if (_ptr_manufacturer_name) {
5896                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
5897                 } else {
5898                         r->manufacturer_name = NULL;
5899                 }
5900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
5901                 if (_ptr_manufacturer_url) {
5902                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
5903                 } else {
5904                         r->manufacturer_url = NULL;
5905                 }
5906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
5907                 if (_ptr_hardware_id) {
5908                         NDR_PULL_ALLOC(ndr, r->hardware_id);
5909                 } else {
5910                         r->hardware_id = NULL;
5911                 }
5912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
5913                 if (_ptr_provider) {
5914                         NDR_PULL_ALLOC(ndr, r->provider);
5915                 } else {
5916                         r->provider = NULL;
5917                 }
5918         }
5919         if (ndr_flags & NDR_BUFFERS) {
5920                 if (r->driver_name) {
5921                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5922                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5925                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5926                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5927                         }
5928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5929                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5931                 }
5932                 if (r->architecture) {
5933                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5934                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5937                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5938                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5939                         }
5940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5943                 }
5944                 if (r->driver_path) {
5945                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5946                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5947                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5948                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5949                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5950                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5951                         }
5952                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5953                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5955                 }
5956                 if (r->data_file) {
5957                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5958                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5961                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5962                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5963                         }
5964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5967                 }
5968                 if (r->config_file) {
5969                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5970                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5973                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5974                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5975                         }
5976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5979                 }
5980                 if (r->help_file) {
5981                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5982                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5985                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5986                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5987                         }
5988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5991                 }
5992                 if (r->monitor_name) {
5993                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5994                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5997                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5998                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5999                         }
6000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6001                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6003                 }
6004                 if (r->default_datatype) {
6005                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6006                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6009                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6010                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
6011                         }
6012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6015                 }
6016                 if (r->dependent_files) {
6017                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6018                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6019                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6021                 }
6022                 if (r->previous_names) {
6023                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6024                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6025                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6027                 }
6028                 if (r->manufacturer_name) {
6029                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6030                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6033                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6034                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
6035                         }
6036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6039                 }
6040                 if (r->manufacturer_url) {
6041                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6042                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6045                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6046                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
6047                         }
6048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6049                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6051                 }
6052                 if (r->hardware_id) {
6053                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6054                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6057                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6058                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
6059                         }
6060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6063                 }
6064                 if (r->provider) {
6065                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6066                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6069                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6070                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
6071                         }
6072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6075                 }
6076         }
6077         return NDR_ERR_SUCCESS;
6078 }
6079
6080 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
6081 {
6082         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
6083         ndr->depth++;
6084         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6085         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6086         ndr->depth++;
6087         if (r->driver_name) {
6088                 ndr_print_string(ndr, "driver_name", r->driver_name);
6089         }
6090         ndr->depth--;
6091         ndr_print_ptr(ndr, "architecture", r->architecture);
6092         ndr->depth++;
6093         if (r->architecture) {
6094                 ndr_print_string(ndr, "architecture", r->architecture);
6095         }
6096         ndr->depth--;
6097         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6098         ndr->depth++;
6099         if (r->driver_path) {
6100                 ndr_print_string(ndr, "driver_path", r->driver_path);
6101         }
6102         ndr->depth--;
6103         ndr_print_ptr(ndr, "data_file", r->data_file);
6104         ndr->depth++;
6105         if (r->data_file) {
6106                 ndr_print_string(ndr, "data_file", r->data_file);
6107         }
6108         ndr->depth--;
6109         ndr_print_ptr(ndr, "config_file", r->config_file);
6110         ndr->depth++;
6111         if (r->config_file) {
6112                 ndr_print_string(ndr, "config_file", r->config_file);
6113         }
6114         ndr->depth--;
6115         ndr_print_ptr(ndr, "help_file", r->help_file);
6116         ndr->depth++;
6117         if (r->help_file) {
6118                 ndr_print_string(ndr, "help_file", r->help_file);
6119         }
6120         ndr->depth--;
6121         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6122         ndr->depth++;
6123         if (r->monitor_name) {
6124                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6125         }
6126         ndr->depth--;
6127         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6128         ndr->depth++;
6129         if (r->default_datatype) {
6130                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6131         }
6132         ndr->depth--;
6133         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
6134         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6135         ndr->depth++;
6136         if (r->dependent_files) {
6137                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6138         }
6139         ndr->depth--;
6140         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
6141         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6142         ndr->depth++;
6143         if (r->previous_names) {
6144                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6145         }
6146         ndr->depth--;
6147         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6148         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6149         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6150         ndr->depth++;
6151         if (r->manufacturer_name) {
6152                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6153         }
6154         ndr->depth--;
6155         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6156         ndr->depth++;
6157         if (r->manufacturer_url) {
6158                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6159         }
6160         ndr->depth--;
6161         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6162         ndr->depth++;
6163         if (r->hardware_id) {
6164                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6165         }
6166         ndr->depth--;
6167         ndr_print_ptr(ndr, "provider", r->provider);
6168         ndr->depth++;
6169         if (r->provider) {
6170                 ndr_print_string(ndr, "provider", r->provider);
6171         }
6172         ndr->depth--;
6173         ndr->depth--;
6174 }
6175
6176 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
6177 {
6178         if (ndr_flags & NDR_SCALARS) {
6179                 NDR_CHECK(ndr_push_align(ndr, 8));
6180                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
6187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
6188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
6189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6190                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
6191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
6193                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
6194                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
6195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
6196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
6197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
6198                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
6199                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
6200                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
6201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
6203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
6204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
6205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
6207                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
6208                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
6209         }
6210         if (ndr_flags & NDR_BUFFERS) {
6211                 if (r->driver_name) {
6212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6213                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6215                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6216                 }
6217                 if (r->architecture) {
6218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6221                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6222                 }
6223                 if (r->driver_path) {
6224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6228                 }
6229                 if (r->data_file) {
6230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6233                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6234                 }
6235                 if (r->config_file) {
6236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6239                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6240                 }
6241                 if (r->help_file) {
6242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6245                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6246                 }
6247                 if (r->monitor_name) {
6248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6252                 }
6253                 if (r->default_datatype) {
6254                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6258                 }
6259                 if (r->dependent_files) {
6260                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6261                 }
6262                 if (r->previous_names) {
6263                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6264                 }
6265                 if (r->manufacturer_name) {
6266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6270                 }
6271                 if (r->manufacturer_url) {
6272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6276                 }
6277                 if (r->hardware_id) {
6278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6282                 }
6283                 if (r->provider) {
6284                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6286                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6288                 }
6289                 if (r->print_processor) {
6290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6293                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6294                 }
6295                 if (r->vendor_setup) {
6296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6300                 }
6301                 if (r->color_profiles) {
6302                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6303                 }
6304                 if (r->inf_path) {
6305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6306                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6307                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6308                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6309                 }
6310                 if (r->core_driver_dependencies) {
6311                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6312                 }
6313         }
6314         return NDR_ERR_SUCCESS;
6315 }
6316
6317 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
6318 {
6319         uint32_t _ptr_driver_name;
6320         TALLOC_CTX *_mem_save_driver_name_0;
6321         uint32_t _ptr_architecture;
6322         TALLOC_CTX *_mem_save_architecture_0;
6323         uint32_t _ptr_driver_path;
6324         TALLOC_CTX *_mem_save_driver_path_0;
6325         uint32_t _ptr_data_file;
6326         TALLOC_CTX *_mem_save_data_file_0;
6327         uint32_t _ptr_config_file;
6328         TALLOC_CTX *_mem_save_config_file_0;
6329         uint32_t _ptr_help_file;
6330         TALLOC_CTX *_mem_save_help_file_0;
6331         uint32_t _ptr_monitor_name;
6332         TALLOC_CTX *_mem_save_monitor_name_0;
6333         uint32_t _ptr_default_datatype;
6334         TALLOC_CTX *_mem_save_default_datatype_0;
6335         uint32_t _ptr_dependent_files;
6336         TALLOC_CTX *_mem_save_dependent_files_0;
6337         uint32_t _ptr_previous_names;
6338         TALLOC_CTX *_mem_save_previous_names_0;
6339         uint32_t _ptr_manufacturer_name;
6340         TALLOC_CTX *_mem_save_manufacturer_name_0;
6341         uint32_t _ptr_manufacturer_url;
6342         TALLOC_CTX *_mem_save_manufacturer_url_0;
6343         uint32_t _ptr_hardware_id;
6344         TALLOC_CTX *_mem_save_hardware_id_0;
6345         uint32_t _ptr_provider;
6346         TALLOC_CTX *_mem_save_provider_0;
6347         uint32_t _ptr_print_processor;
6348         TALLOC_CTX *_mem_save_print_processor_0;
6349         uint32_t _ptr_vendor_setup;
6350         TALLOC_CTX *_mem_save_vendor_setup_0;
6351         uint32_t _ptr_color_profiles;
6352         TALLOC_CTX *_mem_save_color_profiles_0;
6353         uint32_t _ptr_inf_path;
6354         TALLOC_CTX *_mem_save_inf_path_0;
6355         uint32_t _ptr_core_driver_dependencies;
6356         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
6357         if (ndr_flags & NDR_SCALARS) {
6358                 NDR_CHECK(ndr_pull_align(ndr, 8));
6359                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6361                 if (_ptr_driver_name) {
6362                         NDR_PULL_ALLOC(ndr, r->driver_name);
6363                 } else {
6364                         r->driver_name = NULL;
6365                 }
6366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6367                 if (_ptr_architecture) {
6368                         NDR_PULL_ALLOC(ndr, r->architecture);
6369                 } else {
6370                         r->architecture = NULL;
6371                 }
6372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6373                 if (_ptr_driver_path) {
6374                         NDR_PULL_ALLOC(ndr, r->driver_path);
6375                 } else {
6376                         r->driver_path = NULL;
6377                 }
6378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6379                 if (_ptr_data_file) {
6380                         NDR_PULL_ALLOC(ndr, r->data_file);
6381                 } else {
6382                         r->data_file = NULL;
6383                 }
6384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6385                 if (_ptr_config_file) {
6386                         NDR_PULL_ALLOC(ndr, r->config_file);
6387                 } else {
6388                         r->config_file = NULL;
6389                 }
6390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
6391                 if (_ptr_help_file) {
6392                         NDR_PULL_ALLOC(ndr, r->help_file);
6393                 } else {
6394                         r->help_file = NULL;
6395                 }
6396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
6397                 if (_ptr_monitor_name) {
6398                         NDR_PULL_ALLOC(ndr, r->monitor_name);
6399                 } else {
6400                         r->monitor_name = NULL;
6401                 }
6402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
6403                 if (_ptr_default_datatype) {
6404                         NDR_PULL_ALLOC(ndr, r->default_datatype);
6405                 } else {
6406                         r->default_datatype = NULL;
6407                 }
6408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
6409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
6410                 if (_ptr_dependent_files) {
6411                         NDR_PULL_ALLOC(ndr, r->dependent_files);
6412                 } else {
6413                         r->dependent_files = NULL;
6414                 }
6415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
6416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
6417                 if (_ptr_previous_names) {
6418                         NDR_PULL_ALLOC(ndr, r->previous_names);
6419                 } else {
6420                         r->previous_names = NULL;
6421                 }
6422                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
6423                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
6424                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
6425                 if (_ptr_manufacturer_name) {
6426                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
6427                 } else {
6428                         r->manufacturer_name = NULL;
6429                 }
6430                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
6431                 if (_ptr_manufacturer_url) {
6432                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
6433                 } else {
6434                         r->manufacturer_url = NULL;
6435                 }
6436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
6437                 if (_ptr_hardware_id) {
6438                         NDR_PULL_ALLOC(ndr, r->hardware_id);
6439                 } else {
6440                         r->hardware_id = NULL;
6441                 }
6442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
6443                 if (_ptr_provider) {
6444                         NDR_PULL_ALLOC(ndr, r->provider);
6445                 } else {
6446                         r->provider = NULL;
6447                 }
6448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
6449                 if (_ptr_print_processor) {
6450                         NDR_PULL_ALLOC(ndr, r->print_processor);
6451                 } else {
6452                         r->print_processor = NULL;
6453                 }
6454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
6455                 if (_ptr_vendor_setup) {
6456                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
6457                 } else {
6458                         r->vendor_setup = NULL;
6459                 }
6460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
6461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
6462                 if (_ptr_color_profiles) {
6463                         NDR_PULL_ALLOC(ndr, r->color_profiles);
6464                 } else {
6465                         r->color_profiles = NULL;
6466                 }
6467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
6468                 if (_ptr_inf_path) {
6469                         NDR_PULL_ALLOC(ndr, r->inf_path);
6470                 } else {
6471                         r->inf_path = NULL;
6472                 }
6473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
6474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
6475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
6476                 if (_ptr_core_driver_dependencies) {
6477                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
6478                 } else {
6479                         r->core_driver_dependencies = NULL;
6480                 }
6481                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
6482                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
6483         }
6484         if (ndr_flags & NDR_BUFFERS) {
6485                 if (r->driver_name) {
6486                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6487                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6490                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6491                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
6492                         }
6493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6496                 }
6497                 if (r->architecture) {
6498                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6499                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6500                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6501                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6502                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6503                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
6504                         }
6505                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6506                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6508                 }
6509                 if (r->driver_path) {
6510                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6511                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6512                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6513                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6514                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6515                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
6516                         }
6517                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6518                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6520                 }
6521                 if (r->data_file) {
6522                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6523                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6524                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6525                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6526                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6527                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
6528                         }
6529                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6530                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6532                 }
6533                 if (r->config_file) {
6534                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6535                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6536                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6537                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6538                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6539                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
6540                         }
6541                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6542                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6544                 }
6545                 if (r->help_file) {
6546                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6547                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
6548                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
6549                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
6550                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
6551                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
6552                         }
6553                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
6554                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
6555                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
6556                 }
6557                 if (r->monitor_name) {
6558                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6559                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6560                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6561                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6562                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6563                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
6564                         }
6565                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6566                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6568                 }
6569                 if (r->default_datatype) {
6570                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6571                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6572                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6573                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6574                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6575                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
6576                         }
6577                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6578                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6579                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6580                 }
6581                 if (r->dependent_files) {
6582                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6583                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6584                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6586                 }
6587                 if (r->previous_names) {
6588                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6589                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6590                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6592                 }
6593                 if (r->manufacturer_name) {
6594                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6595                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6598                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6599                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
6600                         }
6601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6604                 }
6605                 if (r->manufacturer_url) {
6606                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6607                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6610                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6611                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
6612                         }
6613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6616                 }
6617                 if (r->hardware_id) {
6618                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6619                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6622                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6623                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
6624                         }
6625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6628                 }
6629                 if (r->provider) {
6630                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6631                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6634                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6635                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
6636                         }
6637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6640                 }
6641                 if (r->print_processor) {
6642                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6643                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6645                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6646                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6647                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
6648                         }
6649                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6650                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6652                 }
6653                 if (r->vendor_setup) {
6654                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
6655                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
6656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
6657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
6658                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
6659                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
6660                         }
6661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
6662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
6663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
6664                 }
6665                 if (r->color_profiles) {
6666                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
6667                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
6668                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
6670                 }
6671                 if (r->inf_path) {
6672                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6673                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
6674                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
6675                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
6676                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
6677                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
6678                         }
6679                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
6680                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
6681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
6682                 }
6683                 if (r->core_driver_dependencies) {
6684                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
6685                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
6686                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
6688                 }
6689         }
6690         return NDR_ERR_SUCCESS;
6691 }
6692
6693 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
6694 {
6695         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
6696         ndr->depth++;
6697         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6698         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6699         ndr->depth++;
6700         if (r->driver_name) {
6701                 ndr_print_string(ndr, "driver_name", r->driver_name);
6702         }
6703         ndr->depth--;
6704         ndr_print_ptr(ndr, "architecture", r->architecture);
6705         ndr->depth++;
6706         if (r->architecture) {
6707                 ndr_print_string(ndr, "architecture", r->architecture);
6708         }
6709         ndr->depth--;
6710         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6711         ndr->depth++;
6712         if (r->driver_path) {
6713                 ndr_print_string(ndr, "driver_path", r->driver_path);
6714         }
6715         ndr->depth--;
6716         ndr_print_ptr(ndr, "data_file", r->data_file);
6717         ndr->depth++;
6718         if (r->data_file) {
6719                 ndr_print_string(ndr, "data_file", r->data_file);
6720         }
6721         ndr->depth--;
6722         ndr_print_ptr(ndr, "config_file", r->config_file);
6723         ndr->depth++;
6724         if (r->config_file) {
6725                 ndr_print_string(ndr, "config_file", r->config_file);
6726         }
6727         ndr->depth--;
6728         ndr_print_ptr(ndr, "help_file", r->help_file);
6729         ndr->depth++;
6730         if (r->help_file) {
6731                 ndr_print_string(ndr, "help_file", r->help_file);
6732         }
6733         ndr->depth--;
6734         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6735         ndr->depth++;
6736         if (r->monitor_name) {
6737                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6738         }
6739         ndr->depth--;
6740         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6741         ndr->depth++;
6742         if (r->default_datatype) {
6743                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6744         }
6745         ndr->depth--;
6746         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
6747         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6748         ndr->depth++;
6749         if (r->dependent_files) {
6750                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6751         }
6752         ndr->depth--;
6753         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
6754         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6755         ndr->depth++;
6756         if (r->previous_names) {
6757                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6758         }
6759         ndr->depth--;
6760         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6761         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6762         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6763         ndr->depth++;
6764         if (r->manufacturer_name) {
6765                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6766         }
6767         ndr->depth--;
6768         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6769         ndr->depth++;
6770         if (r->manufacturer_url) {
6771                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6772         }
6773         ndr->depth--;
6774         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6775         ndr->depth++;
6776         if (r->hardware_id) {
6777                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6778         }
6779         ndr->depth--;
6780         ndr_print_ptr(ndr, "provider", r->provider);
6781         ndr->depth++;
6782         if (r->provider) {
6783                 ndr_print_string(ndr, "provider", r->provider);
6784         }
6785         ndr->depth--;
6786         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6787         ndr->depth++;
6788         if (r->print_processor) {
6789                 ndr_print_string(ndr, "print_processor", r->print_processor);
6790         }
6791         ndr->depth--;
6792         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
6793         ndr->depth++;
6794         if (r->vendor_setup) {
6795                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
6796         }
6797         ndr->depth--;
6798         ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
6799         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
6800         ndr->depth++;
6801         if (r->color_profiles) {
6802                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
6803         }
6804         ndr->depth--;
6805         ndr_print_ptr(ndr, "inf_path", r->inf_path);
6806         ndr->depth++;
6807         if (r->inf_path) {
6808                 ndr_print_string(ndr, "inf_path", r->inf_path);
6809         }
6810         ndr->depth--;
6811         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
6812         ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
6813         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6814         ndr->depth++;
6815         if (r->core_driver_dependencies) {
6816                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6817         }
6818         ndr->depth--;
6819         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
6820         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
6821         ndr->depth--;
6822 }
6823
6824 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
6825 {
6826         if (ndr_flags & NDR_SCALARS) {
6827                 int level = ndr_push_get_switch_value(ndr, r);
6828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6829                 switch (level) {
6830                         case 1: {
6831                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6832                         break; }
6833
6834                         case 2: {
6835                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6836                         break; }
6837
6838                         case 3: {
6839                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6840                         break; }
6841
6842                         case 4: {
6843                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6844                         break; }
6845
6846                         case 6: {
6847                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6848                         break; }
6849
6850                         case 8: {
6851                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6852                         break; }
6853
6854                         default:
6855                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6856                 }
6857         }
6858         if (ndr_flags & NDR_BUFFERS) {
6859                 int level = ndr_push_get_switch_value(ndr, r);
6860                 switch (level) {
6861                         case 1:
6862                                 if (r->info1) {
6863                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6864                                 }
6865                         break;
6866
6867                         case 2:
6868                                 if (r->info2) {
6869                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6870                                 }
6871                         break;
6872
6873                         case 3:
6874                                 if (r->info3) {
6875                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6876                                 }
6877                         break;
6878
6879                         case 4:
6880                                 if (r->info4) {
6881                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6882                                 }
6883                         break;
6884
6885                         case 6:
6886                                 if (r->info6) {
6887                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
6888                                 }
6889                         break;
6890
6891                         case 8:
6892                                 if (r->info8) {
6893                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6894                                 }
6895                         break;
6896
6897                         default:
6898                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6899                 }
6900         }
6901         return NDR_ERR_SUCCESS;
6902 }
6903
6904 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
6905 {
6906         int level;
6907         uint32_t _level;
6908         TALLOC_CTX *_mem_save_info1_0;
6909         TALLOC_CTX *_mem_save_info2_0;
6910         TALLOC_CTX *_mem_save_info3_0;
6911         TALLOC_CTX *_mem_save_info4_0;
6912         TALLOC_CTX *_mem_save_info6_0;
6913         TALLOC_CTX *_mem_save_info8_0;
6914         level = ndr_pull_get_switch_value(ndr, r);
6915         if (ndr_flags & NDR_SCALARS) {
6916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6917                 if (_level != level) {
6918                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6919                 }
6920                 switch (level) {
6921                         case 1: {
6922                                 uint32_t _ptr_info1;
6923                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6924                                 if (_ptr_info1) {
6925                                         NDR_PULL_ALLOC(ndr, r->info1);
6926                                 } else {
6927                                         r->info1 = NULL;
6928                                 }
6929                         break; }
6930
6931                         case 2: {
6932                                 uint32_t _ptr_info2;
6933                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6934                                 if (_ptr_info2) {
6935                                         NDR_PULL_ALLOC(ndr, r->info2);
6936                                 } else {
6937                                         r->info2 = NULL;
6938                                 }
6939                         break; }
6940
6941                         case 3: {
6942                                 uint32_t _ptr_info3;
6943                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6944                                 if (_ptr_info3) {
6945                                         NDR_PULL_ALLOC(ndr, r->info3);
6946                                 } else {
6947                                         r->info3 = NULL;
6948                                 }
6949                         break; }
6950
6951                         case 4: {
6952                                 uint32_t _ptr_info4;
6953                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6954                                 if (_ptr_info4) {
6955                                         NDR_PULL_ALLOC(ndr, r->info4);
6956                                 } else {
6957                                         r->info4 = NULL;
6958                                 }
6959                         break; }
6960
6961                         case 6: {
6962                                 uint32_t _ptr_info6;
6963                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
6964                                 if (_ptr_info6) {
6965                                         NDR_PULL_ALLOC(ndr, r->info6);
6966                                 } else {
6967                                         r->info6 = NULL;
6968                                 }
6969                         break; }
6970
6971                         case 8: {
6972                                 uint32_t _ptr_info8;
6973                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
6974                                 if (_ptr_info8) {
6975                                         NDR_PULL_ALLOC(ndr, r->info8);
6976                                 } else {
6977                                         r->info8 = NULL;
6978                                 }
6979                         break; }
6980
6981                         default:
6982                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6983                 }
6984         }
6985         if (ndr_flags & NDR_BUFFERS) {
6986                 switch (level) {
6987                         case 1:
6988                                 if (r->info1) {
6989                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6990                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6991                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6992                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6993                                 }
6994                         break;
6995
6996                         case 2:
6997                                 if (r->info2) {
6998                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6999                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7000                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7001                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7002                                 }
7003                         break;
7004
7005                         case 3:
7006                                 if (r->info3) {
7007                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7008                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7009                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
7010                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7011                                 }
7012                         break;
7013
7014                         case 4:
7015                                 if (r->info4) {
7016                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7017                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7018                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7019                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7020                                 }
7021                         break;
7022
7023                         case 6:
7024                                 if (r->info6) {
7025                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7026                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7027                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
7028                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7029                                 }
7030                         break;
7031
7032                         case 8:
7033                                 if (r->info8) {
7034                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7036                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7037                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7038                                 }
7039                         break;
7040
7041                         default:
7042                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7043                 }
7044         }
7045         return NDR_ERR_SUCCESS;
7046 }
7047
7048 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
7049 {
7050         int level;
7051         level = ndr_print_get_switch_value(ndr, r);
7052         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
7053         switch (level) {
7054                 case 1:
7055                         ndr_print_ptr(ndr, "info1", r->info1);
7056                         ndr->depth++;
7057                         if (r->info1) {
7058                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
7059                         }
7060                         ndr->depth--;
7061                 break;
7062
7063                 case 2:
7064                         ndr_print_ptr(ndr, "info2", r->info2);
7065                         ndr->depth++;
7066                         if (r->info2) {
7067                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
7068                         }
7069                         ndr->depth--;
7070                 break;
7071
7072                 case 3:
7073                         ndr_print_ptr(ndr, "info3", r->info3);
7074                         ndr->depth++;
7075                         if (r->info3) {
7076                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
7077                         }
7078                         ndr->depth--;
7079                 break;
7080
7081                 case 4:
7082                         ndr_print_ptr(ndr, "info4", r->info4);
7083                         ndr->depth++;
7084                         if (r->info4) {
7085                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
7086                         }
7087                         ndr->depth--;
7088                 break;
7089
7090                 case 6:
7091                         ndr_print_ptr(ndr, "info6", r->info6);
7092                         ndr->depth++;
7093                         if (r->info6) {
7094                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
7095                         }
7096                         ndr->depth--;
7097                 break;
7098
7099                 case 8:
7100                         ndr_print_ptr(ndr, "info8", r->info8);
7101                         ndr->depth++;
7102                         if (r->info8) {
7103                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
7104                         }
7105                         ndr->depth--;
7106                 break;
7107
7108                 default:
7109                         ndr_print_bad_level(ndr, name, level);
7110         }
7111 }
7112
7113 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
7114 {
7115         if (ndr_flags & NDR_SCALARS) {
7116                 NDR_CHECK(ndr_push_align(ndr, 4));
7117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7118                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7119                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7120         }
7121         if (ndr_flags & NDR_BUFFERS) {
7122                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7123         }
7124         return NDR_ERR_SUCCESS;
7125 }
7126
7127 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
7128 {
7129         if (ndr_flags & NDR_SCALARS) {
7130                 NDR_CHECK(ndr_pull_align(ndr, 4));
7131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7132                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7133                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7134         }
7135         if (ndr_flags & NDR_BUFFERS) {
7136                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7137         }
7138         return NDR_ERR_SUCCESS;
7139 }
7140
7141 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
7142 {
7143         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
7144         ndr->depth++;
7145         ndr_print_uint32(ndr, "level", r->level);
7146         ndr_print_set_switch_value(ndr, &r->info, r->level);
7147         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
7148         ndr->depth--;
7149 }
7150
7151 static enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
7152 {
7153         if (ndr_flags & NDR_SCALARS) {
7154                 NDR_CHECK(ndr_push_align(ndr, 4));
7155                 {
7156                         uint32_t _flags_save_string = ndr->flags;
7157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7158                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7159                         ndr->flags = _flags_save_string;
7160                 }
7161         }
7162         if (ndr_flags & NDR_BUFFERS) {
7163                 {
7164                         uint32_t _flags_save_string = ndr->flags;
7165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7166                         if (r->driver_name) {
7167                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7168                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7169                         }
7170                         ndr->flags = _flags_save_string;
7171                 }
7172         }
7173         return NDR_ERR_SUCCESS;
7174 }
7175
7176 static enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
7177 {
7178         uint32_t _ptr_driver_name;
7179         TALLOC_CTX *_mem_save_driver_name_0;
7180         if (ndr_flags & NDR_SCALARS) {
7181                 NDR_CHECK(ndr_pull_align(ndr, 4));
7182                 {
7183                         uint32_t _flags_save_string = ndr->flags;
7184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7185                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7186                         if (_ptr_driver_name) {
7187                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7188                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7189                         } else {
7190                                 r->driver_name = NULL;
7191                         }
7192                         ndr->flags = _flags_save_string;
7193                 }
7194         }
7195         if (ndr_flags & NDR_BUFFERS) {
7196                 {
7197                         uint32_t _flags_save_string = ndr->flags;
7198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7199                         if (r->driver_name) {
7200                                 uint32_t _relative_save_offset;
7201                                 _relative_save_offset = ndr->offset;
7202                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7203                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7204                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7205                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7206                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7207                                 ndr->offset = _relative_save_offset;
7208                         }
7209                         ndr->flags = _flags_save_string;
7210                 }
7211         }
7212         return NDR_ERR_SUCCESS;
7213 }
7214
7215 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
7216 {
7217         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
7218         ndr->depth++;
7219         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7220         ndr->depth++;
7221         if (r->driver_name) {
7222                 ndr_print_string(ndr, "driver_name", r->driver_name);
7223         }
7224         ndr->depth--;
7225         ndr->depth--;
7226 }
7227
7228 static enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
7229 {
7230         if (ndr_flags & NDR_SCALARS) {
7231                 NDR_CHECK(ndr_push_align(ndr, 4));
7232                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7233                 {
7234                         uint32_t _flags_save_string = ndr->flags;
7235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7236                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7237                         ndr->flags = _flags_save_string;
7238                 }
7239                 {
7240                         uint32_t _flags_save_string = ndr->flags;
7241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7242                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7243                         ndr->flags = _flags_save_string;
7244                 }
7245                 {
7246                         uint32_t _flags_save_string = ndr->flags;
7247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7248                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7249                         ndr->flags = _flags_save_string;
7250                 }
7251                 {
7252                         uint32_t _flags_save_string = ndr->flags;
7253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7255                         ndr->flags = _flags_save_string;
7256                 }
7257                 {
7258                         uint32_t _flags_save_string = ndr->flags;
7259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7260                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7261                         ndr->flags = _flags_save_string;
7262                 }
7263         }
7264         if (ndr_flags & NDR_BUFFERS) {
7265                 {
7266                         uint32_t _flags_save_string = ndr->flags;
7267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7268                         if (r->driver_name) {
7269                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7270                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7271                         }
7272                         ndr->flags = _flags_save_string;
7273                 }
7274                 {
7275                         uint32_t _flags_save_string = ndr->flags;
7276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7277                         if (r->architecture) {
7278                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7279                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7280                         }
7281                         ndr->flags = _flags_save_string;
7282                 }
7283                 {
7284                         uint32_t _flags_save_string = ndr->flags;
7285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7286                         if (r->driver_path) {
7287                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7288                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7289                         }
7290                         ndr->flags = _flags_save_string;
7291                 }
7292                 {
7293                         uint32_t _flags_save_string = ndr->flags;
7294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7295                         if (r->data_file) {
7296                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7297                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7298                         }
7299                         ndr->flags = _flags_save_string;
7300                 }
7301                 {
7302                         uint32_t _flags_save_string = ndr->flags;
7303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7304                         if (r->config_file) {
7305                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7306                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7307                         }
7308                         ndr->flags = _flags_save_string;
7309                 }
7310         }
7311         return NDR_ERR_SUCCESS;
7312 }
7313
7314 static enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
7315 {
7316         uint32_t _ptr_driver_name;
7317         TALLOC_CTX *_mem_save_driver_name_0;
7318         uint32_t _ptr_architecture;
7319         TALLOC_CTX *_mem_save_architecture_0;
7320         uint32_t _ptr_driver_path;
7321         TALLOC_CTX *_mem_save_driver_path_0;
7322         uint32_t _ptr_data_file;
7323         TALLOC_CTX *_mem_save_data_file_0;
7324         uint32_t _ptr_config_file;
7325         TALLOC_CTX *_mem_save_config_file_0;
7326         if (ndr_flags & NDR_SCALARS) {
7327                 NDR_CHECK(ndr_pull_align(ndr, 4));
7328                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7329                 {
7330                         uint32_t _flags_save_string = ndr->flags;
7331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7332                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7333                         if (_ptr_driver_name) {
7334                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7335                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7336                         } else {
7337                                 r->driver_name = NULL;
7338                         }
7339                         ndr->flags = _flags_save_string;
7340                 }
7341                 {
7342                         uint32_t _flags_save_string = ndr->flags;
7343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7344                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7345                         if (_ptr_architecture) {
7346                                 NDR_PULL_ALLOC(ndr, r->architecture);
7347                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7348                         } else {
7349                                 r->architecture = NULL;
7350                         }
7351                         ndr->flags = _flags_save_string;
7352                 }
7353                 {
7354                         uint32_t _flags_save_string = ndr->flags;
7355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7356                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7357                         if (_ptr_driver_path) {
7358                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7359                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7360                         } else {
7361                                 r->driver_path = NULL;
7362                         }
7363                         ndr->flags = _flags_save_string;
7364                 }
7365                 {
7366                         uint32_t _flags_save_string = ndr->flags;
7367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7368                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7369                         if (_ptr_data_file) {
7370                                 NDR_PULL_ALLOC(ndr, r->data_file);
7371                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7372                         } else {
7373                                 r->data_file = NULL;
7374                         }
7375                         ndr->flags = _flags_save_string;
7376                 }
7377                 {
7378                         uint32_t _flags_save_string = ndr->flags;
7379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7380                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7381                         if (_ptr_config_file) {
7382                                 NDR_PULL_ALLOC(ndr, r->config_file);
7383                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7384                         } else {
7385                                 r->config_file = NULL;
7386                         }
7387                         ndr->flags = _flags_save_string;
7388                 }
7389         }
7390         if (ndr_flags & NDR_BUFFERS) {
7391                 {
7392                         uint32_t _flags_save_string = ndr->flags;
7393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7394                         if (r->driver_name) {
7395                                 uint32_t _relative_save_offset;
7396                                 _relative_save_offset = ndr->offset;
7397                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7398                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7399                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7400                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7401                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7402                                 ndr->offset = _relative_save_offset;
7403                         }
7404                         ndr->flags = _flags_save_string;
7405                 }
7406                 {
7407                         uint32_t _flags_save_string = ndr->flags;
7408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7409                         if (r->architecture) {
7410                                 uint32_t _relative_save_offset;
7411                                 _relative_save_offset = ndr->offset;
7412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7413                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7414                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7417                                 ndr->offset = _relative_save_offset;
7418                         }
7419                         ndr->flags = _flags_save_string;
7420                 }
7421                 {
7422                         uint32_t _flags_save_string = ndr->flags;
7423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7424                         if (r->driver_path) {
7425                                 uint32_t _relative_save_offset;
7426                                 _relative_save_offset = ndr->offset;
7427                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7428                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7429                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7430                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7431                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7432                                 ndr->offset = _relative_save_offset;
7433                         }
7434                         ndr->flags = _flags_save_string;
7435                 }
7436                 {
7437                         uint32_t _flags_save_string = ndr->flags;
7438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7439                         if (r->data_file) {
7440                                 uint32_t _relative_save_offset;
7441                                 _relative_save_offset = ndr->offset;
7442                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7443                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7444                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7445                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7446                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7447                                 ndr->offset = _relative_save_offset;
7448                         }
7449                         ndr->flags = _flags_save_string;
7450                 }
7451                 {
7452                         uint32_t _flags_save_string = ndr->flags;
7453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7454                         if (r->config_file) {
7455                                 uint32_t _relative_save_offset;
7456                                 _relative_save_offset = ndr->offset;
7457                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7458                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7459                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7460                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7461                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7462                                 ndr->offset = _relative_save_offset;
7463                         }
7464                         ndr->flags = _flags_save_string;
7465                 }
7466         }
7467         return NDR_ERR_SUCCESS;
7468 }
7469
7470 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
7471 {
7472         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
7473         ndr->depth++;
7474         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7475         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7476         ndr->depth++;
7477         if (r->driver_name) {
7478                 ndr_print_string(ndr, "driver_name", r->driver_name);
7479         }
7480         ndr->depth--;
7481         ndr_print_ptr(ndr, "architecture", r->architecture);
7482         ndr->depth++;
7483         if (r->architecture) {
7484                 ndr_print_string(ndr, "architecture", r->architecture);
7485         }
7486         ndr->depth--;
7487         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7488         ndr->depth++;
7489         if (r->driver_path) {
7490                 ndr_print_string(ndr, "driver_path", r->driver_path);
7491         }
7492         ndr->depth--;
7493         ndr_print_ptr(ndr, "data_file", r->data_file);
7494         ndr->depth++;
7495         if (r->data_file) {
7496                 ndr_print_string(ndr, "data_file", r->data_file);
7497         }
7498         ndr->depth--;
7499         ndr_print_ptr(ndr, "config_file", r->config_file);
7500         ndr->depth++;
7501         if (r->config_file) {
7502                 ndr_print_string(ndr, "config_file", r->config_file);
7503         }
7504         ndr->depth--;
7505         ndr->depth--;
7506 }
7507
7508 static enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
7509 {
7510         if (ndr_flags & NDR_SCALARS) {
7511                 NDR_CHECK(ndr_push_align(ndr, 4));
7512                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7513                 {
7514                         uint32_t _flags_save_string = ndr->flags;
7515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7516                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7517                         ndr->flags = _flags_save_string;
7518                 }
7519                 {
7520                         uint32_t _flags_save_string = ndr->flags;
7521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7522                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7523                         ndr->flags = _flags_save_string;
7524                 }
7525                 {
7526                         uint32_t _flags_save_string = ndr->flags;
7527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7528                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7529                         ndr->flags = _flags_save_string;
7530                 }
7531                 {
7532                         uint32_t _flags_save_string = ndr->flags;
7533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7534                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7535                         ndr->flags = _flags_save_string;
7536                 }
7537                 {
7538                         uint32_t _flags_save_string = ndr->flags;
7539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7540                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7541                         ndr->flags = _flags_save_string;
7542                 }
7543                 {
7544                         uint32_t _flags_save_string = ndr->flags;
7545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7546                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
7547                         ndr->flags = _flags_save_string;
7548                 }
7549                 {
7550                         uint32_t _flags_save_string_array = ndr->flags;
7551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7552                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
7553                         ndr->flags = _flags_save_string_array;
7554                 }
7555                 {
7556                         uint32_t _flags_save_string = ndr->flags;
7557                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7558                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7559                         ndr->flags = _flags_save_string;
7560                 }
7561                 {
7562                         uint32_t _flags_save_string = ndr->flags;
7563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7564                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
7565                         ndr->flags = _flags_save_string;
7566                 }
7567         }
7568         if (ndr_flags & NDR_BUFFERS) {
7569                 {
7570                         uint32_t _flags_save_string = ndr->flags;
7571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7572                         if (r->driver_name) {
7573                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7574                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7575                         }
7576                         ndr->flags = _flags_save_string;
7577                 }
7578                 {
7579                         uint32_t _flags_save_string = ndr->flags;
7580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7581                         if (r->architecture) {
7582                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7583                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7584                         }
7585                         ndr->flags = _flags_save_string;
7586                 }
7587                 {
7588                         uint32_t _flags_save_string = ndr->flags;
7589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7590                         if (r->driver_path) {
7591                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7592                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7593                         }
7594                         ndr->flags = _flags_save_string;
7595                 }
7596                 {
7597                         uint32_t _flags_save_string = ndr->flags;
7598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7599                         if (r->data_file) {
7600                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7601                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7602                         }
7603                         ndr->flags = _flags_save_string;
7604                 }
7605                 {
7606                         uint32_t _flags_save_string = ndr->flags;
7607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7608                         if (r->config_file) {
7609                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7610                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7611                         }
7612                         ndr->flags = _flags_save_string;
7613                 }
7614                 {
7615                         uint32_t _flags_save_string = ndr->flags;
7616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7617                         if (r->help_file) {
7618                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
7619                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
7620                         }
7621                         ndr->flags = _flags_save_string;
7622                 }
7623                 {
7624                         uint32_t _flags_save_string_array = ndr->flags;
7625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7626                         if (r->dependent_files) {
7627                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
7628                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
7629                         }
7630                         ndr->flags = _flags_save_string_array;
7631                 }
7632                 {
7633                         uint32_t _flags_save_string = ndr->flags;
7634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7635                         if (r->monitor_name) {
7636                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7637                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7638                         }
7639                         ndr->flags = _flags_save_string;
7640                 }
7641                 {
7642                         uint32_t _flags_save_string = ndr->flags;
7643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7644                         if (r->default_datatype) {
7645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
7646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
7647                         }
7648                         ndr->flags = _flags_save_string;
7649                 }
7650         }
7651         return NDR_ERR_SUCCESS;
7652 }
7653
7654 static enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
7655 {
7656         uint32_t _ptr_driver_name;
7657         TALLOC_CTX *_mem_save_driver_name_0;
7658         uint32_t _ptr_architecture;
7659         TALLOC_CTX *_mem_save_architecture_0;
7660         uint32_t _ptr_driver_path;
7661         TALLOC_CTX *_mem_save_driver_path_0;
7662         uint32_t _ptr_data_file;
7663         TALLOC_CTX *_mem_save_data_file_0;
7664         uint32_t _ptr_config_file;
7665         TALLOC_CTX *_mem_save_config_file_0;
7666         uint32_t _ptr_help_file;
7667         TALLOC_CTX *_mem_save_help_file_0;
7668         uint32_t _ptr_dependent_files;
7669         TALLOC_CTX *_mem_save_dependent_files_0;
7670         uint32_t _ptr_monitor_name;
7671         TALLOC_CTX *_mem_save_monitor_name_0;
7672         uint32_t _ptr_default_datatype;
7673         TALLOC_CTX *_mem_save_default_datatype_0;
7674         if (ndr_flags & NDR_SCALARS) {
7675                 NDR_CHECK(ndr_pull_align(ndr, 4));
7676                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7677                 {
7678                         uint32_t _flags_save_string = ndr->flags;
7679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7681                         if (_ptr_driver_name) {
7682                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7684                         } else {
7685                                 r->driver_name = NULL;
7686                         }
7687                         ndr->flags = _flags_save_string;
7688                 }
7689                 {
7690                         uint32_t _flags_save_string = ndr->flags;
7691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7692                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7693                         if (_ptr_architecture) {
7694                                 NDR_PULL_ALLOC(ndr, r->architecture);
7695                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7696                         } else {
7697                                 r->architecture = NULL;
7698                         }
7699                         ndr->flags = _flags_save_string;
7700                 }
7701                 {
7702                         uint32_t _flags_save_string = ndr->flags;
7703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7704                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7705                         if (_ptr_driver_path) {
7706                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7707                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7708                         } else {
7709                                 r->driver_path = NULL;
7710                         }
7711                         ndr->flags = _flags_save_string;
7712                 }
7713                 {
7714                         uint32_t _flags_save_string = ndr->flags;
7715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7716                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7717                         if (_ptr_data_file) {
7718                                 NDR_PULL_ALLOC(ndr, r->data_file);
7719                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7720                         } else {
7721                                 r->data_file = NULL;
7722                         }
7723                         ndr->flags = _flags_save_string;
7724                 }
7725                 {
7726                         uint32_t _flags_save_string = ndr->flags;
7727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7728                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7729                         if (_ptr_config_file) {
7730                                 NDR_PULL_ALLOC(ndr, r->config_file);
7731                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7732                         } else {
7733                                 r->config_file = NULL;
7734                         }
7735                         ndr->flags = _flags_save_string;
7736                 }
7737                 {
7738                         uint32_t _flags_save_string = ndr->flags;
7739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7740                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7741                         if (_ptr_help_file) {
7742                                 NDR_PULL_ALLOC(ndr, r->help_file);
7743                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7744                         } else {
7745                                 r->help_file = NULL;
7746                         }
7747                         ndr->flags = _flags_save_string;
7748                 }
7749                 {
7750                         uint32_t _flags_save_string_array = ndr->flags;
7751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7752                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7753                         if (_ptr_dependent_files) {
7754                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7755                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7756                         } else {
7757                                 r->dependent_files = NULL;
7758                         }
7759                         ndr->flags = _flags_save_string_array;
7760                 }
7761                 {
7762                         uint32_t _flags_save_string = ndr->flags;
7763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7764                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7765                         if (_ptr_monitor_name) {
7766                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7767                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7768                         } else {
7769                                 r->monitor_name = NULL;
7770                         }
7771                         ndr->flags = _flags_save_string;
7772                 }
7773                 {
7774                         uint32_t _flags_save_string = ndr->flags;
7775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7777                         if (_ptr_default_datatype) {
7778                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7780                         } else {
7781                                 r->default_datatype = NULL;
7782                         }
7783                         ndr->flags = _flags_save_string;
7784                 }
7785         }
7786         if (ndr_flags & NDR_BUFFERS) {
7787                 {
7788                         uint32_t _flags_save_string = ndr->flags;
7789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7790                         if (r->driver_name) {
7791                                 uint32_t _relative_save_offset;
7792                                 _relative_save_offset = ndr->offset;
7793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7794                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7795                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7798                                 ndr->offset = _relative_save_offset;
7799                         }
7800                         ndr->flags = _flags_save_string;
7801                 }
7802                 {
7803                         uint32_t _flags_save_string = ndr->flags;
7804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7805                         if (r->architecture) {
7806                                 uint32_t _relative_save_offset;
7807                                 _relative_save_offset = ndr->offset;
7808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7809                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7810                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7813                                 ndr->offset = _relative_save_offset;
7814                         }
7815                         ndr->flags = _flags_save_string;
7816                 }
7817                 {
7818                         uint32_t _flags_save_string = ndr->flags;
7819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7820                         if (r->driver_path) {
7821                                 uint32_t _relative_save_offset;
7822                                 _relative_save_offset = ndr->offset;
7823                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7824                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7825                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7826                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7827                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7828                                 ndr->offset = _relative_save_offset;
7829                         }
7830                         ndr->flags = _flags_save_string;
7831                 }
7832                 {
7833                         uint32_t _flags_save_string = ndr->flags;
7834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7835                         if (r->data_file) {
7836                                 uint32_t _relative_save_offset;
7837                                 _relative_save_offset = ndr->offset;
7838                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7839                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7840                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7841                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7842                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7843                                 ndr->offset = _relative_save_offset;
7844                         }
7845                         ndr->flags = _flags_save_string;
7846                 }
7847                 {
7848                         uint32_t _flags_save_string = ndr->flags;
7849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7850                         if (r->config_file) {
7851                                 uint32_t _relative_save_offset;
7852                                 _relative_save_offset = ndr->offset;
7853                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7854                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7855                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7856                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7857                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7858                                 ndr->offset = _relative_save_offset;
7859                         }
7860                         ndr->flags = _flags_save_string;
7861                 }
7862                 {
7863                         uint32_t _flags_save_string = ndr->flags;
7864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7865                         if (r->help_file) {
7866                                 uint32_t _relative_save_offset;
7867                                 _relative_save_offset = ndr->offset;
7868                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7869                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7870                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7871                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7872                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7873                                 ndr->offset = _relative_save_offset;
7874                         }
7875                         ndr->flags = _flags_save_string;
7876                 }
7877                 {
7878                         uint32_t _flags_save_string_array = ndr->flags;
7879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7880                         if (r->dependent_files) {
7881                                 uint32_t _relative_save_offset;
7882                                 _relative_save_offset = ndr->offset;
7883                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7884                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7885                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7886                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7887                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7888                                 ndr->offset = _relative_save_offset;
7889                         }
7890                         ndr->flags = _flags_save_string_array;
7891                 }
7892                 {
7893                         uint32_t _flags_save_string = ndr->flags;
7894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7895                         if (r->monitor_name) {
7896                                 uint32_t _relative_save_offset;
7897                                 _relative_save_offset = ndr->offset;
7898                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7899                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7900                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7901                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7902                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7903                                 ndr->offset = _relative_save_offset;
7904                         }
7905                         ndr->flags = _flags_save_string;
7906                 }
7907                 {
7908                         uint32_t _flags_save_string = ndr->flags;
7909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7910                         if (r->default_datatype) {
7911                                 uint32_t _relative_save_offset;
7912                                 _relative_save_offset = ndr->offset;
7913                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7914                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7915                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7916                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7917                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7918                                 ndr->offset = _relative_save_offset;
7919                         }
7920                         ndr->flags = _flags_save_string;
7921                 }
7922         }
7923         return NDR_ERR_SUCCESS;
7924 }
7925
7926 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
7927 {
7928         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
7929         ndr->depth++;
7930         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7931         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7932         ndr->depth++;
7933         if (r->driver_name) {
7934                 ndr_print_string(ndr, "driver_name", r->driver_name);
7935         }
7936         ndr->depth--;
7937         ndr_print_ptr(ndr, "architecture", r->architecture);
7938         ndr->depth++;
7939         if (r->architecture) {
7940                 ndr_print_string(ndr, "architecture", r->architecture);
7941         }
7942         ndr->depth--;
7943         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7944         ndr->depth++;
7945         if (r->driver_path) {
7946                 ndr_print_string(ndr, "driver_path", r->driver_path);
7947         }
7948         ndr->depth--;
7949         ndr_print_ptr(ndr, "data_file", r->data_file);
7950         ndr->depth++;
7951         if (r->data_file) {
7952                 ndr_print_string(ndr, "data_file", r->data_file);
7953         }
7954         ndr->depth--;
7955         ndr_print_ptr(ndr, "config_file", r->config_file);
7956         ndr->depth++;
7957         if (r->config_file) {
7958                 ndr_print_string(ndr, "config_file", r->config_file);
7959         }
7960         ndr->depth--;
7961         ndr_print_ptr(ndr, "help_file", r->help_file);
7962         ndr->depth++;
7963         if (r->help_file) {
7964                 ndr_print_string(ndr, "help_file", r->help_file);
7965         }
7966         ndr->depth--;
7967         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7968         ndr->depth++;
7969         if (r->dependent_files) {
7970                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7971         }
7972         ndr->depth--;
7973         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7974         ndr->depth++;
7975         if (r->monitor_name) {
7976                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7977         }
7978         ndr->depth--;
7979         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7980         ndr->depth++;
7981         if (r->default_datatype) {
7982                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7983         }
7984         ndr->depth--;
7985         ndr->depth--;
7986 }
7987
7988 static enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
7989 {
7990         if (ndr_flags & NDR_SCALARS) {
7991                 NDR_CHECK(ndr_push_align(ndr, 4));
7992                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7993                 {
7994                         uint32_t _flags_save_string = ndr->flags;
7995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7996                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7997                         ndr->flags = _flags_save_string;
7998                 }
7999                 {
8000                         uint32_t _flags_save_string = ndr->flags;
8001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8002                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8003                         ndr->flags = _flags_save_string;
8004                 }
8005                 {
8006                         uint32_t _flags_save_string = ndr->flags;
8007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8008                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8009                         ndr->flags = _flags_save_string;
8010                 }
8011                 {
8012                         uint32_t _flags_save_string = ndr->flags;
8013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8014                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8015                         ndr->flags = _flags_save_string;
8016                 }
8017                 {
8018                         uint32_t _flags_save_string = ndr->flags;
8019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8020                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8021                         ndr->flags = _flags_save_string;
8022                 }
8023                 {
8024                         uint32_t _flags_save_string = ndr->flags;
8025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8026                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8027                         ndr->flags = _flags_save_string;
8028                 }
8029                 {
8030                         uint32_t _flags_save_string_array = ndr->flags;
8031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8032                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8033                         ndr->flags = _flags_save_string_array;
8034                 }
8035                 {
8036                         uint32_t _flags_save_string = ndr->flags;
8037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8039                         ndr->flags = _flags_save_string;
8040                 }
8041                 {
8042                         uint32_t _flags_save_string = ndr->flags;
8043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8045                         ndr->flags = _flags_save_string;
8046                 }
8047                 {
8048                         uint32_t _flags_save_string_array = ndr->flags;
8049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8051                         ndr->flags = _flags_save_string_array;
8052                 }
8053         }
8054         if (ndr_flags & NDR_BUFFERS) {
8055                 {
8056                         uint32_t _flags_save_string = ndr->flags;
8057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8058                         if (r->driver_name) {
8059                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8060                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8061                         }
8062                         ndr->flags = _flags_save_string;
8063                 }
8064                 {
8065                         uint32_t _flags_save_string = ndr->flags;
8066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8067                         if (r->architecture) {
8068                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8069                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8070                         }
8071                         ndr->flags = _flags_save_string;
8072                 }
8073                 {
8074                         uint32_t _flags_save_string = ndr->flags;
8075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8076                         if (r->driver_path) {
8077                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8078                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8079                         }
8080                         ndr->flags = _flags_save_string;
8081                 }
8082                 {
8083                         uint32_t _flags_save_string = ndr->flags;
8084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8085                         if (r->data_file) {
8086                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8087                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8088                         }
8089                         ndr->flags = _flags_save_string;
8090                 }
8091                 {
8092                         uint32_t _flags_save_string = ndr->flags;
8093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8094                         if (r->config_file) {
8095                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8096                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8097                         }
8098                         ndr->flags = _flags_save_string;
8099                 }
8100                 {
8101                         uint32_t _flags_save_string = ndr->flags;
8102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8103                         if (r->help_file) {
8104                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8105                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8106                         }
8107                         ndr->flags = _flags_save_string;
8108                 }
8109                 {
8110                         uint32_t _flags_save_string_array = ndr->flags;
8111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8112                         if (r->dependent_files) {
8113                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8114                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8115                         }
8116                         ndr->flags = _flags_save_string_array;
8117                 }
8118                 {
8119                         uint32_t _flags_save_string = ndr->flags;
8120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8121                         if (r->monitor_name) {
8122                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8123                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8124                         }
8125                         ndr->flags = _flags_save_string;
8126                 }
8127                 {
8128                         uint32_t _flags_save_string = ndr->flags;
8129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8130                         if (r->default_datatype) {
8131                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8132                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8133                         }
8134                         ndr->flags = _flags_save_string;
8135                 }
8136                 {
8137                         uint32_t _flags_save_string_array = ndr->flags;
8138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8139                         if (r->previous_names) {
8140                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8141                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8142                         }
8143                         ndr->flags = _flags_save_string_array;
8144                 }
8145         }
8146         return NDR_ERR_SUCCESS;
8147 }
8148
8149 static enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
8150 {
8151         uint32_t _ptr_driver_name;
8152         TALLOC_CTX *_mem_save_driver_name_0;
8153         uint32_t _ptr_architecture;
8154         TALLOC_CTX *_mem_save_architecture_0;
8155         uint32_t _ptr_driver_path;
8156         TALLOC_CTX *_mem_save_driver_path_0;
8157         uint32_t _ptr_data_file;
8158         TALLOC_CTX *_mem_save_data_file_0;
8159         uint32_t _ptr_config_file;
8160         TALLOC_CTX *_mem_save_config_file_0;
8161         uint32_t _ptr_help_file;
8162         TALLOC_CTX *_mem_save_help_file_0;
8163         uint32_t _ptr_dependent_files;
8164         TALLOC_CTX *_mem_save_dependent_files_0;
8165         uint32_t _ptr_monitor_name;
8166         TALLOC_CTX *_mem_save_monitor_name_0;
8167         uint32_t _ptr_default_datatype;
8168         TALLOC_CTX *_mem_save_default_datatype_0;
8169         uint32_t _ptr_previous_names;
8170         TALLOC_CTX *_mem_save_previous_names_0;
8171         if (ndr_flags & NDR_SCALARS) {
8172                 NDR_CHECK(ndr_pull_align(ndr, 4));
8173                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8174                 {
8175                         uint32_t _flags_save_string = ndr->flags;
8176                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8177                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8178                         if (_ptr_driver_name) {
8179                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8180                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8181                         } else {
8182                                 r->driver_name = NULL;
8183                         }
8184                         ndr->flags = _flags_save_string;
8185                 }
8186                 {
8187                         uint32_t _flags_save_string = ndr->flags;
8188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8189                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8190                         if (_ptr_architecture) {
8191                                 NDR_PULL_ALLOC(ndr, r->architecture);
8192                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8193                         } else {
8194                                 r->architecture = NULL;
8195                         }
8196                         ndr->flags = _flags_save_string;
8197                 }
8198                 {
8199                         uint32_t _flags_save_string = ndr->flags;
8200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8201                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8202                         if (_ptr_driver_path) {
8203                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8204                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8205                         } else {
8206                                 r->driver_path = NULL;
8207                         }
8208                         ndr->flags = _flags_save_string;
8209                 }
8210                 {
8211                         uint32_t _flags_save_string = ndr->flags;
8212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8213                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8214                         if (_ptr_data_file) {
8215                                 NDR_PULL_ALLOC(ndr, r->data_file);
8216                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8217                         } else {
8218                                 r->data_file = NULL;
8219                         }
8220                         ndr->flags = _flags_save_string;
8221                 }
8222                 {
8223                         uint32_t _flags_save_string = ndr->flags;
8224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8225                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8226                         if (_ptr_config_file) {
8227                                 NDR_PULL_ALLOC(ndr, r->config_file);
8228                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8229                         } else {
8230                                 r->config_file = NULL;
8231                         }
8232                         ndr->flags = _flags_save_string;
8233                 }
8234                 {
8235                         uint32_t _flags_save_string = ndr->flags;
8236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8237                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8238                         if (_ptr_help_file) {
8239                                 NDR_PULL_ALLOC(ndr, r->help_file);
8240                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
8241                         } else {
8242                                 r->help_file = NULL;
8243                         }
8244                         ndr->flags = _flags_save_string;
8245                 }
8246                 {
8247                         uint32_t _flags_save_string_array = ndr->flags;
8248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8249                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8250                         if (_ptr_dependent_files) {
8251                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
8252                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
8253                         } else {
8254                                 r->dependent_files = NULL;
8255                         }
8256                         ndr->flags = _flags_save_string_array;
8257                 }
8258                 {
8259                         uint32_t _flags_save_string = ndr->flags;
8260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8261                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8262                         if (_ptr_monitor_name) {
8263                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
8264                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
8265                         } else {
8266                                 r->monitor_name = NULL;
8267                         }
8268                         ndr->flags = _flags_save_string;
8269                 }
8270                 {
8271                         uint32_t _flags_save_string = ndr->flags;
8272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8273                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8274                         if (_ptr_default_datatype) {
8275                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
8276                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
8277                         } else {
8278                                 r->default_datatype = NULL;
8279                         }
8280                         ndr->flags = _flags_save_string;
8281                 }
8282                 {
8283                         uint32_t _flags_save_string_array = ndr->flags;
8284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8285                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8286                         if (_ptr_previous_names) {
8287                                 NDR_PULL_ALLOC(ndr, r->previous_names);
8288                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
8289                         } else {
8290                                 r->previous_names = NULL;
8291                         }
8292                         ndr->flags = _flags_save_string_array;
8293                 }
8294         }
8295         if (ndr_flags & NDR_BUFFERS) {
8296                 {
8297                         uint32_t _flags_save_string = ndr->flags;
8298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8299                         if (r->driver_name) {
8300                                 uint32_t _relative_save_offset;
8301                                 _relative_save_offset = ndr->offset;
8302                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8303                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8304                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8305                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8306                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8307                                 ndr->offset = _relative_save_offset;
8308                         }
8309                         ndr->flags = _flags_save_string;
8310                 }
8311                 {
8312                         uint32_t _flags_save_string = ndr->flags;
8313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8314                         if (r->architecture) {
8315                                 uint32_t _relative_save_offset;
8316                                 _relative_save_offset = ndr->offset;
8317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8318                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8319                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8322                                 ndr->offset = _relative_save_offset;
8323                         }
8324                         ndr->flags = _flags_save_string;
8325                 }
8326                 {
8327                         uint32_t _flags_save_string = ndr->flags;
8328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8329                         if (r->driver_path) {
8330                                 uint32_t _relative_save_offset;
8331                                 _relative_save_offset = ndr->offset;
8332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8333                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8334                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8337                                 ndr->offset = _relative_save_offset;
8338                         }
8339                         ndr->flags = _flags_save_string;
8340                 }
8341                 {
8342                         uint32_t _flags_save_string = ndr->flags;
8343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8344                         if (r->data_file) {
8345                                 uint32_t _relative_save_offset;
8346                                 _relative_save_offset = ndr->offset;
8347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8348                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8349                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8352                                 ndr->offset = _relative_save_offset;
8353                         }
8354                         ndr->flags = _flags_save_string;
8355                 }
8356                 {
8357                         uint32_t _flags_save_string = ndr->flags;
8358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8359                         if (r->config_file) {
8360                                 uint32_t _relative_save_offset;
8361                                 _relative_save_offset = ndr->offset;
8362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8363                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8364                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8367                                 ndr->offset = _relative_save_offset;
8368                         }
8369                         ndr->flags = _flags_save_string;
8370                 }
8371                 {
8372                         uint32_t _flags_save_string = ndr->flags;
8373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8374                         if (r->help_file) {
8375                                 uint32_t _relative_save_offset;
8376                                 _relative_save_offset = ndr->offset;
8377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
8378                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8379                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
8381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8382                                 ndr->offset = _relative_save_offset;
8383                         }
8384                         ndr->flags = _flags_save_string;
8385                 }
8386                 {
8387                         uint32_t _flags_save_string_array = ndr->flags;
8388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8389                         if (r->dependent_files) {
8390                                 uint32_t _relative_save_offset;
8391                                 _relative_save_offset = ndr->offset;
8392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
8393                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8394                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8395                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
8396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8397                                 ndr->offset = _relative_save_offset;
8398                         }
8399                         ndr->flags = _flags_save_string_array;
8400                 }
8401                 {
8402                         uint32_t _flags_save_string = ndr->flags;
8403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8404                         if (r->monitor_name) {
8405                                 uint32_t _relative_save_offset;
8406                                 _relative_save_offset = ndr->offset;
8407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
8408                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8409                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8410                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
8411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8412                                 ndr->offset = _relative_save_offset;
8413                         }
8414                         ndr->flags = _flags_save_string;
8415                 }
8416                 {
8417                         uint32_t _flags_save_string = ndr->flags;
8418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8419                         if (r->default_datatype) {
8420                                 uint32_t _relative_save_offset;
8421                                 _relative_save_offset = ndr->offset;
8422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
8423                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8424                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
8426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8427                                 ndr->offset = _relative_save_offset;
8428                         }
8429                         ndr->flags = _flags_save_string;
8430                 }
8431                 {
8432                         uint32_t _flags_save_string_array = ndr->flags;
8433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8434                         if (r->previous_names) {
8435                                 uint32_t _relative_save_offset;
8436                                 _relative_save_offset = ndr->offset;
8437                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
8438                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8439                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8440                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
8441                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8442                                 ndr->offset = _relative_save_offset;
8443                         }
8444                         ndr->flags = _flags_save_string_array;
8445                 }
8446         }
8447         return NDR_ERR_SUCCESS;
8448 }
8449
8450 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
8451 {
8452         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
8453         ndr->depth++;
8454         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8455         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8456         ndr->depth++;
8457         if (r->driver_name) {
8458                 ndr_print_string(ndr, "driver_name", r->driver_name);
8459         }
8460         ndr->depth--;
8461         ndr_print_ptr(ndr, "architecture", r->architecture);
8462         ndr->depth++;
8463         if (r->architecture) {
8464                 ndr_print_string(ndr, "architecture", r->architecture);
8465         }
8466         ndr->depth--;
8467         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8468         ndr->depth++;
8469         if (r->driver_path) {
8470                 ndr_print_string(ndr, "driver_path", r->driver_path);
8471         }
8472         ndr->depth--;
8473         ndr_print_ptr(ndr, "data_file", r->data_file);
8474         ndr->depth++;
8475         if (r->data_file) {
8476                 ndr_print_string(ndr, "data_file", r->data_file);
8477         }
8478         ndr->depth--;
8479         ndr_print_ptr(ndr, "config_file", r->config_file);
8480         ndr->depth++;
8481         if (r->config_file) {
8482                 ndr_print_string(ndr, "config_file", r->config_file);
8483         }
8484         ndr->depth--;
8485         ndr_print_ptr(ndr, "help_file", r->help_file);
8486         ndr->depth++;
8487         if (r->help_file) {
8488                 ndr_print_string(ndr, "help_file", r->help_file);
8489         }
8490         ndr->depth--;
8491         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8492         ndr->depth++;
8493         if (r->dependent_files) {
8494                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
8495         }
8496         ndr->depth--;
8497         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8498         ndr->depth++;
8499         if (r->monitor_name) {
8500                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8501         }
8502         ndr->depth--;
8503         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8504         ndr->depth++;
8505         if (r->default_datatype) {
8506                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8507         }
8508         ndr->depth--;
8509         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8510         ndr->depth++;
8511         if (r->previous_names) {
8512                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
8513         }
8514         ndr->depth--;
8515         ndr->depth--;
8516 }
8517
8518 static enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
8519 {
8520         if (ndr_flags & NDR_SCALARS) {
8521                 NDR_CHECK(ndr_push_align(ndr, 4));
8522                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8523                 {
8524                         uint32_t _flags_save_string = ndr->flags;
8525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8526                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8527                         ndr->flags = _flags_save_string;
8528                 }
8529                 {
8530                         uint32_t _flags_save_string = ndr->flags;
8531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8533                         ndr->flags = _flags_save_string;
8534                 }
8535                 {
8536                         uint32_t _flags_save_string = ndr->flags;
8537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8539                         ndr->flags = _flags_save_string;
8540                 }
8541                 {
8542                         uint32_t _flags_save_string = ndr->flags;
8543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8545                         ndr->flags = _flags_save_string;
8546                 }
8547                 {
8548                         uint32_t _flags_save_string = ndr->flags;
8549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8551                         ndr->flags = _flags_save_string;
8552                 }
8553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
8554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
8555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
8556         }
8557         if (ndr_flags & NDR_BUFFERS) {
8558                 {
8559                         uint32_t _flags_save_string = ndr->flags;
8560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8561                         if (r->driver_name) {
8562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8564                         }
8565                         ndr->flags = _flags_save_string;
8566                 }
8567                 {
8568                         uint32_t _flags_save_string = ndr->flags;
8569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8570                         if (r->architecture) {
8571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8573                         }
8574                         ndr->flags = _flags_save_string;
8575                 }
8576                 {
8577                         uint32_t _flags_save_string = ndr->flags;
8578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8579                         if (r->driver_path) {
8580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8582                         }
8583                         ndr->flags = _flags_save_string;
8584                 }
8585                 {
8586                         uint32_t _flags_save_string = ndr->flags;
8587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8588                         if (r->data_file) {
8589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8591                         }
8592                         ndr->flags = _flags_save_string;
8593                 }
8594                 {
8595                         uint32_t _flags_save_string = ndr->flags;
8596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8597                         if (r->config_file) {
8598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8600                         }
8601                         ndr->flags = _flags_save_string;
8602                 }
8603         }
8604         return NDR_ERR_SUCCESS;
8605 }
8606
8607 static enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
8608 {
8609         uint32_t _ptr_driver_name;
8610         TALLOC_CTX *_mem_save_driver_name_0;
8611         uint32_t _ptr_architecture;
8612         TALLOC_CTX *_mem_save_architecture_0;
8613         uint32_t _ptr_driver_path;
8614         TALLOC_CTX *_mem_save_driver_path_0;
8615         uint32_t _ptr_data_file;
8616         TALLOC_CTX *_mem_save_data_file_0;
8617         uint32_t _ptr_config_file;
8618         TALLOC_CTX *_mem_save_config_file_0;
8619         if (ndr_flags & NDR_SCALARS) {
8620                 NDR_CHECK(ndr_pull_align(ndr, 4));
8621                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8622                 {
8623                         uint32_t _flags_save_string = ndr->flags;
8624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8625                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8626                         if (_ptr_driver_name) {
8627                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8628                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8629                         } else {
8630                                 r->driver_name = NULL;
8631                         }
8632                         ndr->flags = _flags_save_string;
8633                 }
8634                 {
8635                         uint32_t _flags_save_string = ndr->flags;
8636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8637                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8638                         if (_ptr_architecture) {
8639                                 NDR_PULL_ALLOC(ndr, r->architecture);
8640                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8641                         } else {
8642                                 r->architecture = NULL;
8643                         }
8644                         ndr->flags = _flags_save_string;
8645                 }
8646                 {
8647                         uint32_t _flags_save_string = ndr->flags;
8648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8649                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8650                         if (_ptr_driver_path) {
8651                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8652                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8653                         } else {
8654                                 r->driver_path = NULL;
8655                         }
8656                         ndr->flags = _flags_save_string;
8657                 }
8658                 {
8659                         uint32_t _flags_save_string = ndr->flags;
8660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8661                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8662                         if (_ptr_data_file) {
8663                                 NDR_PULL_ALLOC(ndr, r->data_file);
8664                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8665                         } else {
8666                                 r->data_file = NULL;
8667                         }
8668                         ndr->flags = _flags_save_string;
8669                 }
8670                 {
8671                         uint32_t _flags_save_string = ndr->flags;
8672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8673                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8674                         if (_ptr_config_file) {
8675                                 NDR_PULL_ALLOC(ndr, r->config_file);
8676                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8677                         } else {
8678                                 r->config_file = NULL;
8679                         }
8680                         ndr->flags = _flags_save_string;
8681                 }
8682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
8683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
8684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
8685         }
8686         if (ndr_flags & NDR_BUFFERS) {
8687                 {
8688                         uint32_t _flags_save_string = ndr->flags;
8689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8690                         if (r->driver_name) {
8691                                 uint32_t _relative_save_offset;
8692                                 _relative_save_offset = ndr->offset;
8693                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8694                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8695                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8696                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8697                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8698                                 ndr->offset = _relative_save_offset;
8699                         }
8700                         ndr->flags = _flags_save_string;
8701                 }
8702                 {
8703                         uint32_t _flags_save_string = ndr->flags;
8704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8705                         if (r->architecture) {
8706                                 uint32_t _relative_save_offset;
8707                                 _relative_save_offset = ndr->offset;
8708                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8709                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8710                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8711                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8712                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8713                                 ndr->offset = _relative_save_offset;
8714                         }
8715                         ndr->flags = _flags_save_string;
8716                 }
8717                 {
8718                         uint32_t _flags_save_string = ndr->flags;
8719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8720                         if (r->driver_path) {
8721                                 uint32_t _relative_save_offset;
8722                                 _relative_save_offset = ndr->offset;
8723                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8724                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8725                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8726                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8727                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8728                                 ndr->offset = _relative_save_offset;
8729                         }
8730                         ndr->flags = _flags_save_string;
8731                 }
8732                 {
8733                         uint32_t _flags_save_string = ndr->flags;
8734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8735                         if (r->data_file) {
8736                                 uint32_t _relative_save_offset;
8737                                 _relative_save_offset = ndr->offset;
8738                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8739                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8740                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8741                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8742                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8743                                 ndr->offset = _relative_save_offset;
8744                         }
8745                         ndr->flags = _flags_save_string;
8746                 }
8747                 {
8748                         uint32_t _flags_save_string = ndr->flags;
8749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8750                         if (r->config_file) {
8751                                 uint32_t _relative_save_offset;
8752                                 _relative_save_offset = ndr->offset;
8753                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8754                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8755                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8756                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8757                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8758                                 ndr->offset = _relative_save_offset;
8759                         }
8760                         ndr->flags = _flags_save_string;
8761                 }
8762         }
8763         return NDR_ERR_SUCCESS;
8764 }
8765
8766 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
8767 {
8768         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
8769         ndr->depth++;
8770         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8771         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8772         ndr->depth++;
8773         if (r->driver_name) {
8774                 ndr_print_string(ndr, "driver_name", r->driver_name);
8775         }
8776         ndr->depth--;
8777         ndr_print_ptr(ndr, "architecture", r->architecture);
8778         ndr->depth++;
8779         if (r->architecture) {
8780                 ndr_print_string(ndr, "architecture", r->architecture);
8781         }
8782         ndr->depth--;
8783         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8784         ndr->depth++;
8785         if (r->driver_path) {
8786                 ndr_print_string(ndr, "driver_path", r->driver_path);
8787         }
8788         ndr->depth--;
8789         ndr_print_ptr(ndr, "data_file", r->data_file);
8790         ndr->depth++;
8791         if (r->data_file) {
8792                 ndr_print_string(ndr, "data_file", r->data_file);
8793         }
8794         ndr->depth--;
8795         ndr_print_ptr(ndr, "config_file", r->config_file);
8796         ndr->depth++;
8797         if (r->config_file) {
8798                 ndr_print_string(ndr, "config_file", r->config_file);
8799         }
8800         ndr->depth--;
8801         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
8802         ndr_print_uint32(ndr, "config_version", r->config_version);
8803         ndr_print_uint32(ndr, "driver_version", r->driver_version);
8804         ndr->depth--;
8805 }
8806
8807 static enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
8808 {
8809         if (ndr_flags & NDR_SCALARS) {
8810                 NDR_CHECK(ndr_push_align(ndr, 8));
8811                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8812                 {
8813                         uint32_t _flags_save_string = ndr->flags;
8814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8815                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8816                         ndr->flags = _flags_save_string;
8817                 }
8818                 {
8819                         uint32_t _flags_save_string = ndr->flags;
8820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8821                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8822                         ndr->flags = _flags_save_string;
8823                 }
8824                 {
8825                         uint32_t _flags_save_string = ndr->flags;
8826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8827                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8828                         ndr->flags = _flags_save_string;
8829                 }
8830                 {
8831                         uint32_t _flags_save_string = ndr->flags;
8832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8833                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8834                         ndr->flags = _flags_save_string;
8835                 }
8836                 {
8837                         uint32_t _flags_save_string = ndr->flags;
8838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8839                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8840                         ndr->flags = _flags_save_string;
8841                 }
8842                 {
8843                         uint32_t _flags_save_string = ndr->flags;
8844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8845                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8846                         ndr->flags = _flags_save_string;
8847                 }
8848                 {
8849                         uint32_t _flags_save_string_array = ndr->flags;
8850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8851                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8852                         ndr->flags = _flags_save_string_array;
8853                 }
8854                 {
8855                         uint32_t _flags_save_string = ndr->flags;
8856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8857                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8858                         ndr->flags = _flags_save_string;
8859                 }
8860                 {
8861                         uint32_t _flags_save_string = ndr->flags;
8862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8864                         ndr->flags = _flags_save_string;
8865                 }
8866                 {
8867                         uint32_t _flags_save_string_array = ndr->flags;
8868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8870                         ndr->flags = _flags_save_string_array;
8871                 }
8872                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
8873                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8874                 {
8875                         uint32_t _flags_save_string = ndr->flags;
8876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8877                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
8878                         ndr->flags = _flags_save_string;
8879                 }
8880                 {
8881                         uint32_t _flags_save_string = ndr->flags;
8882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8883                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
8884                         ndr->flags = _flags_save_string;
8885                 }
8886                 {
8887                         uint32_t _flags_save_string = ndr->flags;
8888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8889                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
8890                         ndr->flags = _flags_save_string;
8891                 }
8892                 {
8893                         uint32_t _flags_save_string = ndr->flags;
8894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8895                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
8896                         ndr->flags = _flags_save_string;
8897                 }
8898         }
8899         if (ndr_flags & NDR_BUFFERS) {
8900                 {
8901                         uint32_t _flags_save_string = ndr->flags;
8902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8903                         if (r->driver_name) {
8904                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8905                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8906                         }
8907                         ndr->flags = _flags_save_string;
8908                 }
8909                 {
8910                         uint32_t _flags_save_string = ndr->flags;
8911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8912                         if (r->architecture) {
8913                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8914                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8915                         }
8916                         ndr->flags = _flags_save_string;
8917                 }
8918                 {
8919                         uint32_t _flags_save_string = ndr->flags;
8920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8921                         if (r->driver_path) {
8922                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8923                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8924                         }
8925                         ndr->flags = _flags_save_string;
8926                 }
8927                 {
8928                         uint32_t _flags_save_string = ndr->flags;
8929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8930                         if (r->data_file) {
8931                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8932                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8933                         }
8934                         ndr->flags = _flags_save_string;
8935                 }
8936                 {
8937                         uint32_t _flags_save_string = ndr->flags;
8938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8939                         if (r->config_file) {
8940                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8941                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8942                         }
8943                         ndr->flags = _flags_save_string;
8944                 }
8945                 {
8946                         uint32_t _flags_save_string = ndr->flags;
8947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8948                         if (r->help_file) {
8949                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8950                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8951                         }
8952                         ndr->flags = _flags_save_string;
8953                 }
8954                 {
8955                         uint32_t _flags_save_string_array = ndr->flags;
8956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8957                         if (r->dependent_files) {
8958                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8959                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8960                         }
8961                         ndr->flags = _flags_save_string_array;
8962                 }
8963                 {
8964                         uint32_t _flags_save_string = ndr->flags;
8965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8966                         if (r->monitor_name) {
8967                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8968                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8969                         }
8970                         ndr->flags = _flags_save_string;
8971                 }
8972                 {
8973                         uint32_t _flags_save_string = ndr->flags;
8974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8975                         if (r->default_datatype) {
8976                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8977                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8978                         }
8979                         ndr->flags = _flags_save_string;
8980                 }
8981                 {
8982                         uint32_t _flags_save_string_array = ndr->flags;
8983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8984                         if (r->previous_names) {
8985                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8986                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8987                         }
8988                         ndr->flags = _flags_save_string_array;
8989                 }
8990                 {
8991                         uint32_t _flags_save_string = ndr->flags;
8992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8993                         if (r->manufacturer_name) {
8994                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
8995                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
8996                         }
8997                         ndr->flags = _flags_save_string;
8998                 }
8999                 {
9000                         uint32_t _flags_save_string = ndr->flags;
9001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9002                         if (r->manufacturer_url) {
9003                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9004                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9005                         }
9006                         ndr->flags = _flags_save_string;
9007                 }
9008                 {
9009                         uint32_t _flags_save_string = ndr->flags;
9010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9011                         if (r->hardware_id) {
9012                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9013                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9014                         }
9015                         ndr->flags = _flags_save_string;
9016                 }
9017                 {
9018                         uint32_t _flags_save_string = ndr->flags;
9019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9020                         if (r->provider) {
9021                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9022                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9023                         }
9024                         ndr->flags = _flags_save_string;
9025                 }
9026         }
9027         return NDR_ERR_SUCCESS;
9028 }
9029
9030 static enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
9031 {
9032         uint32_t _ptr_driver_name;
9033         TALLOC_CTX *_mem_save_driver_name_0;
9034         uint32_t _ptr_architecture;
9035         TALLOC_CTX *_mem_save_architecture_0;
9036         uint32_t _ptr_driver_path;
9037         TALLOC_CTX *_mem_save_driver_path_0;
9038         uint32_t _ptr_data_file;
9039         TALLOC_CTX *_mem_save_data_file_0;
9040         uint32_t _ptr_config_file;
9041         TALLOC_CTX *_mem_save_config_file_0;
9042         uint32_t _ptr_help_file;
9043         TALLOC_CTX *_mem_save_help_file_0;
9044         uint32_t _ptr_dependent_files;
9045         TALLOC_CTX *_mem_save_dependent_files_0;
9046         uint32_t _ptr_monitor_name;
9047         TALLOC_CTX *_mem_save_monitor_name_0;
9048         uint32_t _ptr_default_datatype;
9049         TALLOC_CTX *_mem_save_default_datatype_0;
9050         uint32_t _ptr_previous_names;
9051         TALLOC_CTX *_mem_save_previous_names_0;
9052         uint32_t _ptr_manufacturer_name;
9053         TALLOC_CTX *_mem_save_manufacturer_name_0;
9054         uint32_t _ptr_manufacturer_url;
9055         TALLOC_CTX *_mem_save_manufacturer_url_0;
9056         uint32_t _ptr_hardware_id;
9057         TALLOC_CTX *_mem_save_hardware_id_0;
9058         uint32_t _ptr_provider;
9059         TALLOC_CTX *_mem_save_provider_0;
9060         if (ndr_flags & NDR_SCALARS) {
9061                 NDR_CHECK(ndr_pull_align(ndr, 8));
9062                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9063                 {
9064                         uint32_t _flags_save_string = ndr->flags;
9065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9066                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9067                         if (_ptr_driver_name) {
9068                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9069                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9070                         } else {
9071                                 r->driver_name = NULL;
9072                         }
9073                         ndr->flags = _flags_save_string;
9074                 }
9075                 {
9076                         uint32_t _flags_save_string = ndr->flags;
9077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9078                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9079                         if (_ptr_architecture) {
9080                                 NDR_PULL_ALLOC(ndr, r->architecture);
9081                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9082                         } else {
9083                                 r->architecture = NULL;
9084                         }
9085                         ndr->flags = _flags_save_string;
9086                 }
9087                 {
9088                         uint32_t _flags_save_string = ndr->flags;
9089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9090                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9091                         if (_ptr_driver_path) {
9092                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9093                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9094                         } else {
9095                                 r->driver_path = NULL;
9096                         }
9097                         ndr->flags = _flags_save_string;
9098                 }
9099                 {
9100                         uint32_t _flags_save_string = ndr->flags;
9101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9102                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9103                         if (_ptr_data_file) {
9104                                 NDR_PULL_ALLOC(ndr, r->data_file);
9105                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9106                         } else {
9107                                 r->data_file = NULL;
9108                         }
9109                         ndr->flags = _flags_save_string;
9110                 }
9111                 {
9112                         uint32_t _flags_save_string = ndr->flags;
9113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9114                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9115                         if (_ptr_config_file) {
9116                                 NDR_PULL_ALLOC(ndr, r->config_file);
9117                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9118                         } else {
9119                                 r->config_file = NULL;
9120                         }
9121                         ndr->flags = _flags_save_string;
9122                 }
9123                 {
9124                         uint32_t _flags_save_string = ndr->flags;
9125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9126                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9127                         if (_ptr_help_file) {
9128                                 NDR_PULL_ALLOC(ndr, r->help_file);
9129                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9130                         } else {
9131                                 r->help_file = NULL;
9132                         }
9133                         ndr->flags = _flags_save_string;
9134                 }
9135                 {
9136                         uint32_t _flags_save_string_array = ndr->flags;
9137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9138                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9139                         if (_ptr_dependent_files) {
9140                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9141                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9142                         } else {
9143                                 r->dependent_files = NULL;
9144                         }
9145                         ndr->flags = _flags_save_string_array;
9146                 }
9147                 {
9148                         uint32_t _flags_save_string = ndr->flags;
9149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9150                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9151                         if (_ptr_monitor_name) {
9152                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9153                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9154                         } else {
9155                                 r->monitor_name = NULL;
9156                         }
9157                         ndr->flags = _flags_save_string;
9158                 }
9159                 {
9160                         uint32_t _flags_save_string = ndr->flags;
9161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9162                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9163                         if (_ptr_default_datatype) {
9164                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9165                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9166                         } else {
9167                                 r->default_datatype = NULL;
9168                         }
9169                         ndr->flags = _flags_save_string;
9170                 }
9171                 {
9172                         uint32_t _flags_save_string_array = ndr->flags;
9173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9174                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9175                         if (_ptr_previous_names) {
9176                                 NDR_PULL_ALLOC(ndr, r->previous_names);
9177                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
9178                         } else {
9179                                 r->previous_names = NULL;
9180                         }
9181                         ndr->flags = _flags_save_string_array;
9182                 }
9183                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
9184                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9185                 {
9186                         uint32_t _flags_save_string = ndr->flags;
9187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9188                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9189                         if (_ptr_manufacturer_name) {
9190                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9191                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
9192                         } else {
9193                                 r->manufacturer_name = NULL;
9194                         }
9195                         ndr->flags = _flags_save_string;
9196                 }
9197                 {
9198                         uint32_t _flags_save_string = ndr->flags;
9199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9200                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9201                         if (_ptr_manufacturer_url) {
9202                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9203                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
9204                         } else {
9205                                 r->manufacturer_url = NULL;
9206                         }
9207                         ndr->flags = _flags_save_string;
9208                 }
9209                 {
9210                         uint32_t _flags_save_string = ndr->flags;
9211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9212                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9213                         if (_ptr_hardware_id) {
9214                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
9215                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
9216                         } else {
9217                                 r->hardware_id = NULL;
9218                         }
9219                         ndr->flags = _flags_save_string;
9220                 }
9221                 {
9222                         uint32_t _flags_save_string = ndr->flags;
9223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9225                         if (_ptr_provider) {
9226                                 NDR_PULL_ALLOC(ndr, r->provider);
9227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
9228                         } else {
9229                                 r->provider = NULL;
9230                         }
9231                         ndr->flags = _flags_save_string;
9232                 }
9233         }
9234         if (ndr_flags & NDR_BUFFERS) {
9235                 {
9236                         uint32_t _flags_save_string = ndr->flags;
9237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9238                         if (r->driver_name) {
9239                                 uint32_t _relative_save_offset;
9240                                 _relative_save_offset = ndr->offset;
9241                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9242                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9243                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9244                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9245                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9246                                 ndr->offset = _relative_save_offset;
9247                         }
9248                         ndr->flags = _flags_save_string;
9249                 }
9250                 {
9251                         uint32_t _flags_save_string = ndr->flags;
9252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9253                         if (r->architecture) {
9254                                 uint32_t _relative_save_offset;
9255                                 _relative_save_offset = ndr->offset;
9256                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9257                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9258                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9259                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9260                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9261                                 ndr->offset = _relative_save_offset;
9262                         }
9263                         ndr->flags = _flags_save_string;
9264                 }
9265                 {
9266                         uint32_t _flags_save_string = ndr->flags;
9267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9268                         if (r->driver_path) {
9269                                 uint32_t _relative_save_offset;
9270                                 _relative_save_offset = ndr->offset;
9271                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9272                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9273                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9274                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9275                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9276                                 ndr->offset = _relative_save_offset;
9277                         }
9278                         ndr->flags = _flags_save_string;
9279                 }
9280                 {
9281                         uint32_t _flags_save_string = ndr->flags;
9282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9283                         if (r->data_file) {
9284                                 uint32_t _relative_save_offset;
9285                                 _relative_save_offset = ndr->offset;
9286                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9287                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9288                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9289                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9290                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9291                                 ndr->offset = _relative_save_offset;
9292                         }
9293                         ndr->flags = _flags_save_string;
9294                 }
9295                 {
9296                         uint32_t _flags_save_string = ndr->flags;
9297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9298                         if (r->config_file) {
9299                                 uint32_t _relative_save_offset;
9300                                 _relative_save_offset = ndr->offset;
9301                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9302                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9303                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9304                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9305                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9306                                 ndr->offset = _relative_save_offset;
9307                         }
9308                         ndr->flags = _flags_save_string;
9309                 }
9310                 {
9311                         uint32_t _flags_save_string = ndr->flags;
9312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9313                         if (r->help_file) {
9314                                 uint32_t _relative_save_offset;
9315                                 _relative_save_offset = ndr->offset;
9316                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9317                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9318                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9319                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9320                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9321                                 ndr->offset = _relative_save_offset;
9322                         }
9323                         ndr->flags = _flags_save_string;
9324                 }
9325                 {
9326                         uint32_t _flags_save_string_array = ndr->flags;
9327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9328                         if (r->dependent_files) {
9329                                 uint32_t _relative_save_offset;
9330                                 _relative_save_offset = ndr->offset;
9331                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9332                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9333                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9334                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9335                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9336                                 ndr->offset = _relative_save_offset;
9337                         }
9338                         ndr->flags = _flags_save_string_array;
9339                 }
9340                 {
9341                         uint32_t _flags_save_string = ndr->flags;
9342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9343                         if (r->monitor_name) {
9344                                 uint32_t _relative_save_offset;
9345                                 _relative_save_offset = ndr->offset;
9346                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9347                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9348                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9349                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9350                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9351                                 ndr->offset = _relative_save_offset;
9352                         }
9353                         ndr->flags = _flags_save_string;
9354                 }
9355                 {
9356                         uint32_t _flags_save_string = ndr->flags;
9357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9358                         if (r->default_datatype) {
9359                                 uint32_t _relative_save_offset;
9360                                 _relative_save_offset = ndr->offset;
9361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9362                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9363                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9366                                 ndr->offset = _relative_save_offset;
9367                         }
9368                         ndr->flags = _flags_save_string;
9369                 }
9370                 {
9371                         uint32_t _flags_save_string_array = ndr->flags;
9372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9373                         if (r->previous_names) {
9374                                 uint32_t _relative_save_offset;
9375                                 _relative_save_offset = ndr->offset;
9376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
9377                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9378                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9379                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
9380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9381                                 ndr->offset = _relative_save_offset;
9382                         }
9383                         ndr->flags = _flags_save_string_array;
9384                 }
9385                 {
9386                         uint32_t _flags_save_string = ndr->flags;
9387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9388                         if (r->manufacturer_name) {
9389                                 uint32_t _relative_save_offset;
9390                                 _relative_save_offset = ndr->offset;
9391                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
9392                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9393                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9394                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
9395                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9396                                 ndr->offset = _relative_save_offset;
9397                         }
9398                         ndr->flags = _flags_save_string;
9399                 }
9400                 {
9401                         uint32_t _flags_save_string = ndr->flags;
9402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9403                         if (r->manufacturer_url) {
9404                                 uint32_t _relative_save_offset;
9405                                 _relative_save_offset = ndr->offset;
9406                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
9407                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9408                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9409                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
9410                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9411                                 ndr->offset = _relative_save_offset;
9412                         }
9413                         ndr->flags = _flags_save_string;
9414                 }
9415                 {
9416                         uint32_t _flags_save_string = ndr->flags;
9417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9418                         if (r->hardware_id) {
9419                                 uint32_t _relative_save_offset;
9420                                 _relative_save_offset = ndr->offset;
9421                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
9422                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9423                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9424                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
9425                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9426                                 ndr->offset = _relative_save_offset;
9427                         }
9428                         ndr->flags = _flags_save_string;
9429                 }
9430                 {
9431                         uint32_t _flags_save_string = ndr->flags;
9432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9433                         if (r->provider) {
9434                                 uint32_t _relative_save_offset;
9435                                 _relative_save_offset = ndr->offset;
9436                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
9437                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9438                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9439                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
9440                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9441                                 ndr->offset = _relative_save_offset;
9442                         }
9443                         ndr->flags = _flags_save_string;
9444                 }
9445         }
9446         return NDR_ERR_SUCCESS;
9447 }
9448
9449 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
9450 {
9451         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
9452         ndr->depth++;
9453         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9454         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9455         ndr->depth++;
9456         if (r->driver_name) {
9457                 ndr_print_string(ndr, "driver_name", r->driver_name);
9458         }
9459         ndr->depth--;
9460         ndr_print_ptr(ndr, "architecture", r->architecture);
9461         ndr->depth++;
9462         if (r->architecture) {
9463                 ndr_print_string(ndr, "architecture", r->architecture);
9464         }
9465         ndr->depth--;
9466         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9467         ndr->depth++;
9468         if (r->driver_path) {
9469                 ndr_print_string(ndr, "driver_path", r->driver_path);
9470         }
9471         ndr->depth--;
9472         ndr_print_ptr(ndr, "data_file", r->data_file);
9473         ndr->depth++;
9474         if (r->data_file) {
9475                 ndr_print_string(ndr, "data_file", r->data_file);
9476         }
9477         ndr->depth--;
9478         ndr_print_ptr(ndr, "config_file", r->config_file);
9479         ndr->depth++;
9480         if (r->config_file) {
9481                 ndr_print_string(ndr, "config_file", r->config_file);
9482         }
9483         ndr->depth--;
9484         ndr_print_ptr(ndr, "help_file", r->help_file);
9485         ndr->depth++;
9486         if (r->help_file) {
9487                 ndr_print_string(ndr, "help_file", r->help_file);
9488         }
9489         ndr->depth--;
9490         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9491         ndr->depth++;
9492         if (r->dependent_files) {
9493                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9494         }
9495         ndr->depth--;
9496         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9497         ndr->depth++;
9498         if (r->monitor_name) {
9499                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9500         }
9501         ndr->depth--;
9502         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9503         ndr->depth++;
9504         if (r->default_datatype) {
9505                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9506         }
9507         ndr->depth--;
9508         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9509         ndr->depth++;
9510         if (r->previous_names) {
9511                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
9512         }
9513         ndr->depth--;
9514         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
9515         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9516         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9517         ndr->depth++;
9518         if (r->manufacturer_name) {
9519                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9520         }
9521         ndr->depth--;
9522         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9523         ndr->depth++;
9524         if (r->manufacturer_url) {
9525                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9526         }
9527         ndr->depth--;
9528         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9529         ndr->depth++;
9530         if (r->hardware_id) {
9531                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9532         }
9533         ndr->depth--;
9534         ndr_print_ptr(ndr, "provider", r->provider);
9535         ndr->depth++;
9536         if (r->provider) {
9537                 ndr_print_string(ndr, "provider", r->provider);
9538         }
9539         ndr->depth--;
9540         ndr->depth--;
9541 }
9542
9543 static enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
9544 {
9545         if (ndr_flags & NDR_SCALARS) {
9546                 NDR_CHECK(ndr_push_align(ndr, 8));
9547                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9548                 {
9549                         uint32_t _flags_save_string = ndr->flags;
9550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9551                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9552                         ndr->flags = _flags_save_string;
9553                 }
9554                 {
9555                         uint32_t _flags_save_string = ndr->flags;
9556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9557                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9558                         ndr->flags = _flags_save_string;
9559                 }
9560                 {
9561                         uint32_t _flags_save_string = ndr->flags;
9562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9563                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9564                         ndr->flags = _flags_save_string;
9565                 }
9566                 {
9567                         uint32_t _flags_save_string = ndr->flags;
9568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9570                         ndr->flags = _flags_save_string;
9571                 }
9572                 {
9573                         uint32_t _flags_save_string = ndr->flags;
9574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9576                         ndr->flags = _flags_save_string;
9577                 }
9578                 {
9579                         uint32_t _flags_save_string = ndr->flags;
9580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
9582                         ndr->flags = _flags_save_string;
9583                 }
9584                 {
9585                         uint32_t _flags_save_string = ndr->flags;
9586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
9588                         ndr->flags = _flags_save_string;
9589                 }
9590                 {
9591                         uint32_t _flags_save_string = ndr->flags;
9592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
9594                         ndr->flags = _flags_save_string;
9595                 }
9596                 {
9597                         uint32_t _flags_save_string_array = ndr->flags;
9598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
9600                         ndr->flags = _flags_save_string_array;
9601                 }
9602                 {
9603                         uint32_t _flags_save_string_array = ndr->flags;
9604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
9606                         ndr->flags = _flags_save_string_array;
9607                 }
9608                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
9609                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9610                 {
9611                         uint32_t _flags_save_string = ndr->flags;
9612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9613                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
9614                         ndr->flags = _flags_save_string;
9615                 }
9616                 {
9617                         uint32_t _flags_save_string = ndr->flags;
9618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9619                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
9620                         ndr->flags = _flags_save_string;
9621                 }
9622                 {
9623                         uint32_t _flags_save_string = ndr->flags;
9624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9625                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
9626                         ndr->flags = _flags_save_string;
9627                 }
9628                 {
9629                         uint32_t _flags_save_string = ndr->flags;
9630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9631                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
9632                         ndr->flags = _flags_save_string;
9633                 }
9634                 {
9635                         uint32_t _flags_save_string = ndr->flags;
9636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
9638                         ndr->flags = _flags_save_string;
9639                 }
9640                 {
9641                         uint32_t _flags_save_string = ndr->flags;
9642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9643                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
9644                         ndr->flags = _flags_save_string;
9645                 }
9646                 {
9647                         uint32_t _flags_save_string_array = ndr->flags;
9648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9649                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
9650                         ndr->flags = _flags_save_string_array;
9651                 }
9652                 {
9653                         uint32_t _flags_save_string = ndr->flags;
9654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9655                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
9656                         ndr->flags = _flags_save_string;
9657                 }
9658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9659                 {
9660                         uint32_t _flags_save_string_array = ndr->flags;
9661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9662                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
9663                         ndr->flags = _flags_save_string_array;
9664                 }
9665                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9666                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9667         }
9668         if (ndr_flags & NDR_BUFFERS) {
9669                 {
9670                         uint32_t _flags_save_string = ndr->flags;
9671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9672                         if (r->driver_name) {
9673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9675                         }
9676                         ndr->flags = _flags_save_string;
9677                 }
9678                 {
9679                         uint32_t _flags_save_string = ndr->flags;
9680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9681                         if (r->architecture) {
9682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9684                         }
9685                         ndr->flags = _flags_save_string;
9686                 }
9687                 {
9688                         uint32_t _flags_save_string = ndr->flags;
9689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9690                         if (r->driver_path) {
9691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9693                         }
9694                         ndr->flags = _flags_save_string;
9695                 }
9696                 {
9697                         uint32_t _flags_save_string = ndr->flags;
9698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9699                         if (r->data_file) {
9700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9702                         }
9703                         ndr->flags = _flags_save_string;
9704                 }
9705                 {
9706                         uint32_t _flags_save_string = ndr->flags;
9707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9708                         if (r->config_file) {
9709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9711                         }
9712                         ndr->flags = _flags_save_string;
9713                 }
9714                 {
9715                         uint32_t _flags_save_string = ndr->flags;
9716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9717                         if (r->help_file) {
9718                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
9719                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
9720                         }
9721                         ndr->flags = _flags_save_string;
9722                 }
9723                 {
9724                         uint32_t _flags_save_string = ndr->flags;
9725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9726                         if (r->monitor_name) {
9727                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
9728                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
9729                         }
9730                         ndr->flags = _flags_save_string;
9731                 }
9732                 {
9733                         uint32_t _flags_save_string = ndr->flags;
9734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9735                         if (r->default_datatype) {
9736                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9737                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9738                         }
9739                         ndr->flags = _flags_save_string;
9740                 }
9741                 {
9742                         uint32_t _flags_save_string_array = ndr->flags;
9743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9744                         if (r->dependent_files) {
9745                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
9746                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
9747                         }
9748                         ndr->flags = _flags_save_string_array;
9749                 }
9750                 {
9751                         uint32_t _flags_save_string_array = ndr->flags;
9752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9753                         if (r->previous_names) {
9754                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9755                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9756                         }
9757                         ndr->flags = _flags_save_string_array;
9758                 }
9759                 {
9760                         uint32_t _flags_save_string = ndr->flags;
9761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9762                         if (r->manufacturer_name) {
9763                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9764                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9765                         }
9766                         ndr->flags = _flags_save_string;
9767                 }
9768                 {
9769                         uint32_t _flags_save_string = ndr->flags;
9770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9771                         if (r->manufacturer_url) {
9772                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9773                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9774                         }
9775                         ndr->flags = _flags_save_string;
9776                 }
9777                 {
9778                         uint32_t _flags_save_string = ndr->flags;
9779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9780                         if (r->hardware_id) {
9781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9783                         }
9784                         ndr->flags = _flags_save_string;
9785                 }
9786                 {
9787                         uint32_t _flags_save_string = ndr->flags;
9788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9789                         if (r->provider) {
9790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9792                         }
9793                         ndr->flags = _flags_save_string;
9794                 }
9795                 {
9796                         uint32_t _flags_save_string = ndr->flags;
9797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9798                         if (r->print_processor) {
9799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
9800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
9801                         }
9802                         ndr->flags = _flags_save_string;
9803                 }
9804                 {
9805                         uint32_t _flags_save_string = ndr->flags;
9806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9807                         if (r->vendor_setup) {
9808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
9809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
9810                         }
9811                         ndr->flags = _flags_save_string;
9812                 }
9813                 {
9814                         uint32_t _flags_save_string_array = ndr->flags;
9815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9816                         if (r->color_profiles) {
9817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
9818                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
9819                         }
9820                         ndr->flags = _flags_save_string_array;
9821                 }
9822                 {
9823                         uint32_t _flags_save_string = ndr->flags;
9824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9825                         if (r->inf_path) {
9826                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
9827                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
9828                         }
9829                         ndr->flags = _flags_save_string;
9830                 }
9831                 {
9832                         uint32_t _flags_save_string_array = ndr->flags;
9833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9834                         if (r->core_driver_dependencies) {
9835                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
9836                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
9837                         }
9838                         ndr->flags = _flags_save_string_array;
9839                 }
9840         }
9841         return NDR_ERR_SUCCESS;
9842 }
9843
9844 static enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
9845 {
9846         uint32_t _ptr_driver_name;
9847         TALLOC_CTX *_mem_save_driver_name_0;
9848         uint32_t _ptr_architecture;
9849         TALLOC_CTX *_mem_save_architecture_0;
9850         uint32_t _ptr_driver_path;
9851         TALLOC_CTX *_mem_save_driver_path_0;
9852         uint32_t _ptr_data_file;
9853         TALLOC_CTX *_mem_save_data_file_0;
9854         uint32_t _ptr_config_file;
9855         TALLOC_CTX *_mem_save_config_file_0;
9856         uint32_t _ptr_help_file;
9857         TALLOC_CTX *_mem_save_help_file_0;
9858         uint32_t _ptr_monitor_name;
9859         TALLOC_CTX *_mem_save_monitor_name_0;
9860         uint32_t _ptr_default_datatype;
9861         TALLOC_CTX *_mem_save_default_datatype_0;
9862         uint32_t _ptr_dependent_files;
9863         TALLOC_CTX *_mem_save_dependent_files_0;
9864         uint32_t _ptr_previous_names;
9865         TALLOC_CTX *_mem_save_previous_names_0;
9866         uint32_t _ptr_manufacturer_name;
9867         TALLOC_CTX *_mem_save_manufacturer_name_0;
9868         uint32_t _ptr_manufacturer_url;
9869         TALLOC_CTX *_mem_save_manufacturer_url_0;
9870         uint32_t _ptr_hardware_id;
9871         TALLOC_CTX *_mem_save_hardware_id_0;
9872         uint32_t _ptr_provider;
9873         TALLOC_CTX *_mem_save_provider_0;
9874         uint32_t _ptr_print_processor;
9875         TALLOC_CTX *_mem_save_print_processor_0;
9876         uint32_t _ptr_vendor_setup;
9877         TALLOC_CTX *_mem_save_vendor_setup_0;
9878         uint32_t _ptr_color_profiles;
9879         TALLOC_CTX *_mem_save_color_profiles_0;
9880         uint32_t _ptr_inf_path;
9881         TALLOC_CTX *_mem_save_inf_path_0;
9882         uint32_t _ptr_core_driver_dependencies;
9883         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9884         if (ndr_flags & NDR_SCALARS) {
9885                 NDR_CHECK(ndr_pull_align(ndr, 8));
9886                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9887                 {
9888                         uint32_t _flags_save_string = ndr->flags;
9889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9891                         if (_ptr_driver_name) {
9892                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9894                         } else {
9895                                 r->driver_name = NULL;
9896                         }
9897                         ndr->flags = _flags_save_string;
9898                 }
9899                 {
9900                         uint32_t _flags_save_string = ndr->flags;
9901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9902                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9903                         if (_ptr_architecture) {
9904                                 NDR_PULL_ALLOC(ndr, r->architecture);
9905                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9906                         } else {
9907                                 r->architecture = NULL;
9908                         }
9909                         ndr->flags = _flags_save_string;
9910                 }
9911                 {
9912                         uint32_t _flags_save_string = ndr->flags;
9913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9914                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9915                         if (_ptr_driver_path) {
9916                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9917                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9918                         } else {
9919                                 r->driver_path = NULL;
9920                         }
9921                         ndr->flags = _flags_save_string;
9922                 }
9923                 {
9924                         uint32_t _flags_save_string = ndr->flags;
9925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9926                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9927                         if (_ptr_data_file) {
9928                                 NDR_PULL_ALLOC(ndr, r->data_file);
9929                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9930                         } else {
9931                                 r->data_file = NULL;
9932                         }
9933                         ndr->flags = _flags_save_string;
9934                 }
9935                 {
9936                         uint32_t _flags_save_string = ndr->flags;
9937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9938                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9939                         if (_ptr_config_file) {
9940                                 NDR_PULL_ALLOC(ndr, r->config_file);
9941                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9942                         } else {
9943                                 r->config_file = NULL;
9944                         }
9945                         ndr->flags = _flags_save_string;
9946                 }
9947                 {
9948                         uint32_t _flags_save_string = ndr->flags;
9949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9951                         if (_ptr_help_file) {
9952                                 NDR_PULL_ALLOC(ndr, r->help_file);
9953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9954                         } else {
9955                                 r->help_file = NULL;
9956                         }
9957                         ndr->flags = _flags_save_string;
9958                 }
9959                 {
9960                         uint32_t _flags_save_string = ndr->flags;
9961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9962                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9963                         if (_ptr_monitor_name) {
9964                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9965                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9966                         } else {
9967                                 r->monitor_name = NULL;
9968                         }
9969                         ndr->flags = _flags_save_string;
9970                 }
9971                 {
9972                         uint32_t _flags_save_string = ndr->flags;
9973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9974                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9975                         if (_ptr_default_datatype) {
9976                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9977                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9978                         } else {
9979                                 r->default_datatype = NULL;
9980                         }
9981                         ndr->flags = _flags_save_string;
9982                 }
9983                 {
9984                         uint32_t _flags_save_string_array = ndr->flags;
9985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9986                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9987                         if (_ptr_dependent_files) {
9988                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9989                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9990                         } else {
9991                                 r->dependent_files = NULL;
9992                         }
9993                         ndr->flags = _flags_save_string_array;
9994                 }
9995                 {
9996                         uint32_t _flags_save_string_array = ndr->flags;
9997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9998                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9999                         if (_ptr_previous_names) {
10000                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10001                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10002                         } else {
10003                                 r->previous_names = NULL;
10004                         }
10005                         ndr->flags = _flags_save_string_array;
10006                 }
10007                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
10008                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10009                 {
10010                         uint32_t _flags_save_string = ndr->flags;
10011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10012                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10013                         if (_ptr_manufacturer_name) {
10014                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10015                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
10016                         } else {
10017                                 r->manufacturer_name = NULL;
10018                         }
10019                         ndr->flags = _flags_save_string;
10020                 }
10021                 {
10022                         uint32_t _flags_save_string = ndr->flags;
10023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10025                         if (_ptr_manufacturer_url) {
10026                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
10028                         } else {
10029                                 r->manufacturer_url = NULL;
10030                         }
10031                         ndr->flags = _flags_save_string;
10032                 }
10033                 {
10034                         uint32_t _flags_save_string = ndr->flags;
10035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10036                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10037                         if (_ptr_hardware_id) {
10038                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
10039                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
10040                         } else {
10041                                 r->hardware_id = NULL;
10042                         }
10043                         ndr->flags = _flags_save_string;
10044                 }
10045                 {
10046                         uint32_t _flags_save_string = ndr->flags;
10047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10048                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10049                         if (_ptr_provider) {
10050                                 NDR_PULL_ALLOC(ndr, r->provider);
10051                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
10052                         } else {
10053                                 r->provider = NULL;
10054                         }
10055                         ndr->flags = _flags_save_string;
10056                 }
10057                 {
10058                         uint32_t _flags_save_string = ndr->flags;
10059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10060                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10061                         if (_ptr_print_processor) {
10062                                 NDR_PULL_ALLOC(ndr, r->print_processor);
10063                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
10064                         } else {
10065                                 r->print_processor = NULL;
10066                         }
10067                         ndr->flags = _flags_save_string;
10068                 }
10069                 {
10070                         uint32_t _flags_save_string = ndr->flags;
10071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10072                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10073                         if (_ptr_vendor_setup) {
10074                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
10075                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
10076                         } else {
10077                                 r->vendor_setup = NULL;
10078                         }
10079                         ndr->flags = _flags_save_string;
10080                 }
10081                 {
10082                         uint32_t _flags_save_string_array = ndr->flags;
10083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10084                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10085                         if (_ptr_color_profiles) {
10086                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
10087                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
10088                         } else {
10089                                 r->color_profiles = NULL;
10090                         }
10091                         ndr->flags = _flags_save_string_array;
10092                 }
10093                 {
10094                         uint32_t _flags_save_string = ndr->flags;
10095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10096                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10097                         if (_ptr_inf_path) {
10098                                 NDR_PULL_ALLOC(ndr, r->inf_path);
10099                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
10100                         } else {
10101                                 r->inf_path = NULL;
10102                         }
10103                         ndr->flags = _flags_save_string;
10104                 }
10105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10106                 {
10107                         uint32_t _flags_save_string_array = ndr->flags;
10108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10109                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10110                         if (_ptr_core_driver_dependencies) {
10111                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10112                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
10113                         } else {
10114                                 r->core_driver_dependencies = NULL;
10115                         }
10116                         ndr->flags = _flags_save_string_array;
10117                 }
10118                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10119                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10120         }
10121         if (ndr_flags & NDR_BUFFERS) {
10122                 {
10123                         uint32_t _flags_save_string = ndr->flags;
10124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10125                         if (r->driver_name) {
10126                                 uint32_t _relative_save_offset;
10127                                 _relative_save_offset = ndr->offset;
10128                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10129                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10130                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10131                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10132                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10133                                 ndr->offset = _relative_save_offset;
10134                         }
10135                         ndr->flags = _flags_save_string;
10136                 }
10137                 {
10138                         uint32_t _flags_save_string = ndr->flags;
10139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10140                         if (r->architecture) {
10141                                 uint32_t _relative_save_offset;
10142                                 _relative_save_offset = ndr->offset;
10143                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10144                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10145                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10146                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10147                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10148                                 ndr->offset = _relative_save_offset;
10149                         }
10150                         ndr->flags = _flags_save_string;
10151                 }
10152                 {
10153                         uint32_t _flags_save_string = ndr->flags;
10154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10155                         if (r->driver_path) {
10156                                 uint32_t _relative_save_offset;
10157                                 _relative_save_offset = ndr->offset;
10158                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10159                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10160                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10161                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10162                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10163                                 ndr->offset = _relative_save_offset;
10164                         }
10165                         ndr->flags = _flags_save_string;
10166                 }
10167                 {
10168                         uint32_t _flags_save_string = ndr->flags;
10169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10170                         if (r->data_file) {
10171                                 uint32_t _relative_save_offset;
10172                                 _relative_save_offset = ndr->offset;
10173                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10174                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10175                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10176                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10177                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10178                                 ndr->offset = _relative_save_offset;
10179                         }
10180                         ndr->flags = _flags_save_string;
10181                 }
10182                 {
10183                         uint32_t _flags_save_string = ndr->flags;
10184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10185                         if (r->config_file) {
10186                                 uint32_t _relative_save_offset;
10187                                 _relative_save_offset = ndr->offset;
10188                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10189                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10190                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10191                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10192                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10193                                 ndr->offset = _relative_save_offset;
10194                         }
10195                         ndr->flags = _flags_save_string;
10196                 }
10197                 {
10198                         uint32_t _flags_save_string = ndr->flags;
10199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10200                         if (r->help_file) {
10201                                 uint32_t _relative_save_offset;
10202                                 _relative_save_offset = ndr->offset;
10203                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10204                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10205                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10206                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10207                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10208                                 ndr->offset = _relative_save_offset;
10209                         }
10210                         ndr->flags = _flags_save_string;
10211                 }
10212                 {
10213                         uint32_t _flags_save_string = ndr->flags;
10214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10215                         if (r->monitor_name) {
10216                                 uint32_t _relative_save_offset;
10217                                 _relative_save_offset = ndr->offset;
10218                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10219                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10220                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10221                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10222                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10223                                 ndr->offset = _relative_save_offset;
10224                         }
10225                         ndr->flags = _flags_save_string;
10226                 }
10227                 {
10228                         uint32_t _flags_save_string = ndr->flags;
10229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10230                         if (r->default_datatype) {
10231                                 uint32_t _relative_save_offset;
10232                                 _relative_save_offset = ndr->offset;
10233                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10234                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10235                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10236                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10237                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10238                                 ndr->offset = _relative_save_offset;
10239                         }
10240                         ndr->flags = _flags_save_string;
10241                 }
10242                 {
10243                         uint32_t _flags_save_string_array = ndr->flags;
10244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10245                         if (r->dependent_files) {
10246                                 uint32_t _relative_save_offset;
10247                                 _relative_save_offset = ndr->offset;
10248                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10249                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10250                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10251                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10252                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10253                                 ndr->offset = _relative_save_offset;
10254                         }
10255                         ndr->flags = _flags_save_string_array;
10256                 }
10257                 {
10258                         uint32_t _flags_save_string_array = ndr->flags;
10259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10260                         if (r->previous_names) {
10261                                 uint32_t _relative_save_offset;
10262                                 _relative_save_offset = ndr->offset;
10263                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
10264                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10265                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10266                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
10267                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10268                                 ndr->offset = _relative_save_offset;
10269                         }
10270                         ndr->flags = _flags_save_string_array;
10271                 }
10272                 {
10273                         uint32_t _flags_save_string = ndr->flags;
10274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10275                         if (r->manufacturer_name) {
10276                                 uint32_t _relative_save_offset;
10277                                 _relative_save_offset = ndr->offset;
10278                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
10279                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10280                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10281                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
10282                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10283                                 ndr->offset = _relative_save_offset;
10284                         }
10285                         ndr->flags = _flags_save_string;
10286                 }
10287                 {
10288                         uint32_t _flags_save_string = ndr->flags;
10289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10290                         if (r->manufacturer_url) {
10291                                 uint32_t _relative_save_offset;
10292                                 _relative_save_offset = ndr->offset;
10293                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
10294                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10295                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10296                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
10297                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10298                                 ndr->offset = _relative_save_offset;
10299                         }
10300                         ndr->flags = _flags_save_string;
10301                 }
10302                 {
10303                         uint32_t _flags_save_string = ndr->flags;
10304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10305                         if (r->hardware_id) {
10306                                 uint32_t _relative_save_offset;
10307                                 _relative_save_offset = ndr->offset;
10308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
10309                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10310                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
10312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10313                                 ndr->offset = _relative_save_offset;
10314                         }
10315                         ndr->flags = _flags_save_string;
10316                 }
10317                 {
10318                         uint32_t _flags_save_string = ndr->flags;
10319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10320                         if (r->provider) {
10321                                 uint32_t _relative_save_offset;
10322                                 _relative_save_offset = ndr->offset;
10323                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
10324                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10325                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10326                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
10327                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10328                                 ndr->offset = _relative_save_offset;
10329                         }
10330                         ndr->flags = _flags_save_string;
10331                 }
10332                 {
10333                         uint32_t _flags_save_string = ndr->flags;
10334                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10335                         if (r->print_processor) {
10336                                 uint32_t _relative_save_offset;
10337                                 _relative_save_offset = ndr->offset;
10338                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
10339                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10340                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10341                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
10342                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10343                                 ndr->offset = _relative_save_offset;
10344                         }
10345                         ndr->flags = _flags_save_string;
10346                 }
10347                 {
10348                         uint32_t _flags_save_string = ndr->flags;
10349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10350                         if (r->vendor_setup) {
10351                                 uint32_t _relative_save_offset;
10352                                 _relative_save_offset = ndr->offset;
10353                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
10354                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10355                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10356                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
10357                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10358                                 ndr->offset = _relative_save_offset;
10359                         }
10360                         ndr->flags = _flags_save_string;
10361                 }
10362                 {
10363                         uint32_t _flags_save_string_array = ndr->flags;
10364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10365                         if (r->color_profiles) {
10366                                 uint32_t _relative_save_offset;
10367                                 _relative_save_offset = ndr->offset;
10368                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
10369                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10370                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10371                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
10372                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10373                                 ndr->offset = _relative_save_offset;
10374                         }
10375                         ndr->flags = _flags_save_string_array;
10376                 }
10377                 {
10378                         uint32_t _flags_save_string = ndr->flags;
10379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10380                         if (r->inf_path) {
10381                                 uint32_t _relative_save_offset;
10382                                 _relative_save_offset = ndr->offset;
10383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
10384                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10385                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
10387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10388                                 ndr->offset = _relative_save_offset;
10389                         }
10390                         ndr->flags = _flags_save_string;
10391                 }
10392                 {
10393                         uint32_t _flags_save_string_array = ndr->flags;
10394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10395                         if (r->core_driver_dependencies) {
10396                                 uint32_t _relative_save_offset;
10397                                 _relative_save_offset = ndr->offset;
10398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
10399                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10400                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10401                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
10402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10403                                 ndr->offset = _relative_save_offset;
10404                         }
10405                         ndr->flags = _flags_save_string_array;
10406                 }
10407         }
10408         return NDR_ERR_SUCCESS;
10409 }
10410
10411 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
10412 {
10413         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
10414         ndr->depth++;
10415         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10416         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10417         ndr->depth++;
10418         if (r->driver_name) {
10419                 ndr_print_string(ndr, "driver_name", r->driver_name);
10420         }
10421         ndr->depth--;
10422         ndr_print_ptr(ndr, "architecture", r->architecture);
10423         ndr->depth++;
10424         if (r->architecture) {
10425                 ndr_print_string(ndr, "architecture", r->architecture);
10426         }
10427         ndr->depth--;
10428         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10429         ndr->depth++;
10430         if (r->driver_path) {
10431                 ndr_print_string(ndr, "driver_path", r->driver_path);
10432         }
10433         ndr->depth--;
10434         ndr_print_ptr(ndr, "data_file", r->data_file);
10435         ndr->depth++;
10436         if (r->data_file) {
10437                 ndr_print_string(ndr, "data_file", r->data_file);
10438         }
10439         ndr->depth--;
10440         ndr_print_ptr(ndr, "config_file", r->config_file);
10441         ndr->depth++;
10442         if (r->config_file) {
10443                 ndr_print_string(ndr, "config_file", r->config_file);
10444         }
10445         ndr->depth--;
10446         ndr_print_ptr(ndr, "help_file", r->help_file);
10447         ndr->depth++;
10448         if (r->help_file) {
10449                 ndr_print_string(ndr, "help_file", r->help_file);
10450         }
10451         ndr->depth--;
10452         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10453         ndr->depth++;
10454         if (r->monitor_name) {
10455                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10456         }
10457         ndr->depth--;
10458         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10459         ndr->depth++;
10460         if (r->default_datatype) {
10461                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10462         }
10463         ndr->depth--;
10464         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10465         ndr->depth++;
10466         if (r->dependent_files) {
10467                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10468         }
10469         ndr->depth--;
10470         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10471         ndr->depth++;
10472         if (r->previous_names) {
10473                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10474         }
10475         ndr->depth--;
10476         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
10477         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10478         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10479         ndr->depth++;
10480         if (r->manufacturer_name) {
10481                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10482         }
10483         ndr->depth--;
10484         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10485         ndr->depth++;
10486         if (r->manufacturer_url) {
10487                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10488         }
10489         ndr->depth--;
10490         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10491         ndr->depth++;
10492         if (r->hardware_id) {
10493                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10494         }
10495         ndr->depth--;
10496         ndr_print_ptr(ndr, "provider", r->provider);
10497         ndr->depth++;
10498         if (r->provider) {
10499                 ndr_print_string(ndr, "provider", r->provider);
10500         }
10501         ndr->depth--;
10502         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10503         ndr->depth++;
10504         if (r->print_processor) {
10505                 ndr_print_string(ndr, "print_processor", r->print_processor);
10506         }
10507         ndr->depth--;
10508         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10509         ndr->depth++;
10510         if (r->vendor_setup) {
10511                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10512         }
10513         ndr->depth--;
10514         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10515         ndr->depth++;
10516         if (r->color_profiles) {
10517                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
10518         }
10519         ndr->depth--;
10520         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10521         ndr->depth++;
10522         if (r->inf_path) {
10523                 ndr_print_string(ndr, "inf_path", r->inf_path);
10524         }
10525         ndr->depth--;
10526         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10527         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10528         ndr->depth++;
10529         if (r->core_driver_dependencies) {
10530                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10531         }
10532         ndr->depth--;
10533         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10534         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10535         ndr->depth--;
10536 }
10537
10538 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
10539 {
10540         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10541         if (ndr_flags & NDR_SCALARS) {
10542                 int level = ndr_push_get_switch_value(ndr, r);
10543                 switch (level) {
10544                         case 1: {
10545                                 NDR_CHECK(ndr_push_align(ndr, 4));
10546                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10547                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10548                         break; }
10549
10550                         case 2: {
10551                                 NDR_CHECK(ndr_push_align(ndr, 4));
10552                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10553                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10554                         break; }
10555
10556                         case 3: {
10557                                 NDR_CHECK(ndr_push_align(ndr, 4));
10558                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10559                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10560                         break; }
10561
10562                         case 4: {
10563                                 NDR_CHECK(ndr_push_align(ndr, 4));
10564                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10565                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10566                         break; }
10567
10568                         case 5: {
10569                                 NDR_CHECK(ndr_push_align(ndr, 4));
10570                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10571                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10572                         break; }
10573
10574                         case 6: {
10575                                 NDR_CHECK(ndr_push_align(ndr, 8));
10576                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10577                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10578                         break; }
10579
10580                         case 8: {
10581                                 NDR_CHECK(ndr_push_align(ndr, 8));
10582                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10583                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10584                         break; }
10585
10586                         default: {
10587                         break; }
10588
10589                 }
10590         }
10591         if (ndr_flags & NDR_BUFFERS) {
10592                 int level = ndr_push_get_switch_value(ndr, r);
10593                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10594                 switch (level) {
10595                         case 1:
10596                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10597                         break;
10598
10599                         case 2:
10600                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10601                         break;
10602
10603                         case 3:
10604                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10605                         break;
10606
10607                         case 4:
10608                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10609                         break;
10610
10611                         case 5:
10612                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10613                         break;
10614
10615                         case 6:
10616                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10617                         break;
10618
10619                         case 8:
10620                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10621                         break;
10622
10623                         default:
10624                         break;
10625
10626                 }
10627         }
10628         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10629         return NDR_ERR_SUCCESS;
10630 }
10631
10632 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
10633 {
10634         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10635         int level;
10636         level = ndr_pull_get_switch_value(ndr, r);
10637         if (ndr_flags & NDR_SCALARS) {
10638                 switch (level) {
10639                         case 1: {
10640                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10641                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10642                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10643                         break; }
10644
10645                         case 2: {
10646                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10647                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10648                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10649                         break; }
10650
10651                         case 3: {
10652                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10653                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10654                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10655                         break; }
10656
10657                         case 4: {
10658                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10659                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10660                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10661                         break; }
10662
10663                         case 5: {
10664                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10665                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10666                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10667                         break; }
10668
10669                         case 6: {
10670                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10671                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10672                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10673                         break; }
10674
10675                         case 8: {
10676                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10677                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10678                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10679                         break; }
10680
10681                         default: {
10682                         break; }
10683
10684                 }
10685         }
10686         if (ndr_flags & NDR_BUFFERS) {
10687                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10688                 switch (level) {
10689                         case 1:
10690                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10691                         break;
10692
10693                         case 2:
10694                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10695                         break;
10696
10697                         case 3:
10698                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10699                         break;
10700
10701                         case 4:
10702                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10703                         break;
10704
10705                         case 5:
10706                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10707                         break;
10708
10709                         case 6:
10710                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10711                         break;
10712
10713                         case 8:
10714                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10715                         break;
10716
10717                         default:
10718                         break;
10719
10720                 }
10721         }
10722         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10723         return NDR_ERR_SUCCESS;
10724 }
10725
10726 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
10727 {
10728         int level;
10729         level = ndr_print_get_switch_value(ndr, r);
10730         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
10731         switch (level) {
10732                 case 1:
10733                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
10734                 break;
10735
10736                 case 2:
10737                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
10738                 break;
10739
10740                 case 3:
10741                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
10742                 break;
10743
10744                 case 4:
10745                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
10746                 break;
10747
10748                 case 5:
10749                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
10750                 break;
10751
10752                 case 6:
10753                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
10754                 break;
10755
10756                 case 8:
10757                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
10758                 break;
10759
10760                 default:
10761                 break;
10762
10763         }
10764 }
10765
10766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
10767 {
10768         if (ndr_flags & NDR_SCALARS) {
10769                 NDR_CHECK(ndr_push_align(ndr, 4));
10770                 {
10771                         uint32_t _flags_save_string = ndr->flags;
10772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10773                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
10774                         ndr->flags = _flags_save_string;
10775                 }
10776         }
10777         if (ndr_flags & NDR_BUFFERS) {
10778         }
10779         return NDR_ERR_SUCCESS;
10780 }
10781
10782 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
10783 {
10784         if (ndr_flags & NDR_SCALARS) {
10785                 NDR_CHECK(ndr_pull_align(ndr, 4));
10786                 {
10787                         uint32_t _flags_save_string = ndr->flags;
10788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10789                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
10790                         ndr->flags = _flags_save_string;
10791                 }
10792         }
10793         if (ndr_flags & NDR_BUFFERS) {
10794         }
10795         return NDR_ERR_SUCCESS;
10796 }
10797
10798 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
10799 {
10800         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
10801         ndr->depth++;
10802         ndr_print_string(ndr, "directory_name", r->directory_name);
10803         ndr->depth--;
10804 }
10805
10806 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10807 {
10808         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
10809 }
10810
10811 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
10812 {
10813         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10814         if (ndr_flags & NDR_SCALARS) {
10815                 int level = ndr_push_get_switch_value(ndr, r);
10816                 switch (level) {
10817                         case 1: {
10818                                 NDR_CHECK(ndr_push_align(ndr, 4));
10819                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10820                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10821                         break; }
10822
10823                         default: {
10824                                 NDR_CHECK(ndr_push_align(ndr, 4));
10825                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10826                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10827                         break; }
10828
10829                 }
10830         }
10831         if (ndr_flags & NDR_BUFFERS) {
10832                 int level = ndr_push_get_switch_value(ndr, r);
10833                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10834                 switch (level) {
10835                         case 1:
10836                         break;
10837
10838                         default:
10839                         break;
10840
10841                 }
10842         }
10843         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10844         return NDR_ERR_SUCCESS;
10845 }
10846
10847 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
10848 {
10849         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10850         int level;
10851         level = ndr_pull_get_switch_value(ndr, r);
10852         if (ndr_flags & NDR_SCALARS) {
10853                 switch (level) {
10854                         case 1: {
10855                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10856                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10857                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10858                         break; }
10859
10860                         default: {
10861                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10862                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10863                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10864                         break; }
10865
10866                 }
10867         }
10868         if (ndr_flags & NDR_BUFFERS) {
10869                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10870                 switch (level) {
10871                         case 1:
10872                         break;
10873
10874                         default:
10875                         break;
10876
10877                 }
10878         }
10879         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10880         return NDR_ERR_SUCCESS;
10881 }
10882
10883 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
10884 {
10885         int level;
10886         level = ndr_print_get_switch_value(ndr, r);
10887         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
10888         switch (level) {
10889                 case 1:
10890                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10891                 break;
10892
10893                 default:
10894                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10895                 break;
10896
10897         }
10898 }
10899
10900 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
10901 {
10902         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
10903 }
10904
10905 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
10906 {
10907         if (ndr_flags & NDR_SCALARS) {
10908                 NDR_CHECK(ndr_push_align(ndr, 4));
10909                 {
10910                         uint32_t _flags_save_string = ndr->flags;
10911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10912                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
10913                         ndr->flags = _flags_save_string;
10914                 }
10915         }
10916         if (ndr_flags & NDR_BUFFERS) {
10917                 {
10918                         uint32_t _flags_save_string = ndr->flags;
10919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10920                         if (r->print_processor_name) {
10921                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
10922                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
10923                         }
10924                         ndr->flags = _flags_save_string;
10925                 }
10926         }
10927         return NDR_ERR_SUCCESS;
10928 }
10929
10930 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
10931 {
10932         uint32_t _ptr_print_processor_name;
10933         TALLOC_CTX *_mem_save_print_processor_name_0;
10934         if (ndr_flags & NDR_SCALARS) {
10935                 NDR_CHECK(ndr_pull_align(ndr, 4));
10936                 {
10937                         uint32_t _flags_save_string = ndr->flags;
10938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10939                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
10940                         if (_ptr_print_processor_name) {
10941                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
10942                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
10943                         } else {
10944                                 r->print_processor_name = NULL;
10945                         }
10946                         ndr->flags = _flags_save_string;
10947                 }
10948         }
10949         if (ndr_flags & NDR_BUFFERS) {
10950                 {
10951                         uint32_t _flags_save_string = ndr->flags;
10952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10953                         if (r->print_processor_name) {
10954                                 uint32_t _relative_save_offset;
10955                                 _relative_save_offset = ndr->offset;
10956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
10957                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10958                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
10959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
10960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
10961                                 ndr->offset = _relative_save_offset;
10962                         }
10963                         ndr->flags = _flags_save_string;
10964                 }
10965         }
10966         return NDR_ERR_SUCCESS;
10967 }
10968
10969 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
10970 {
10971         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
10972         ndr->depth++;
10973         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
10974         ndr->depth++;
10975         if (r->print_processor_name) {
10976                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
10977         }
10978         ndr->depth--;
10979         ndr->depth--;
10980 }
10981
10982 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
10983 {
10984         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10985         if (ndr_flags & NDR_SCALARS) {
10986                 int level = ndr_push_get_switch_value(ndr, r);
10987                 switch (level) {
10988                         case 1: {
10989                                 NDR_CHECK(ndr_push_align(ndr, 4));
10990                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10991                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
10992                         break; }
10993
10994                         default: {
10995                         break; }
10996
10997                 }
10998         }
10999         if (ndr_flags & NDR_BUFFERS) {
11000                 int level = ndr_push_get_switch_value(ndr, r);
11001                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11002                 switch (level) {
11003                         case 1:
11004                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11005                         break;
11006
11007                         default:
11008                         break;
11009
11010                 }
11011         }
11012         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11013         return NDR_ERR_SUCCESS;
11014 }
11015
11016 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
11017 {
11018         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11019         int level;
11020         level = ndr_pull_get_switch_value(ndr, r);
11021         if (ndr_flags & NDR_SCALARS) {
11022                 switch (level) {
11023                         case 1: {
11024                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11025                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11026                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11027                         break; }
11028
11029                         default: {
11030                         break; }
11031
11032                 }
11033         }
11034         if (ndr_flags & NDR_BUFFERS) {
11035                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11036                 switch (level) {
11037                         case 1:
11038                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11039                         break;
11040
11041                         default:
11042                         break;
11043
11044                 }
11045         }
11046         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11047         return NDR_ERR_SUCCESS;
11048 }
11049
11050 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
11051 {
11052         int level;
11053         level = ndr_print_get_switch_value(ndr, r);
11054         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
11055         switch (level) {
11056                 case 1:
11057                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
11058                 break;
11059
11060                 default:
11061                 break;
11062
11063         }
11064 }
11065
11066 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11067 {
11068         if (ndr_flags & NDR_SCALARS) {
11069                 NDR_CHECK(ndr_push_align(ndr, 4));
11070                 {
11071                         uint32_t _flags_save_string = ndr->flags;
11072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11073                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
11074                         ndr->flags = _flags_save_string;
11075                 }
11076         }
11077         if (ndr_flags & NDR_BUFFERS) {
11078         }
11079         return NDR_ERR_SUCCESS;
11080 }
11081
11082 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
11083 {
11084         if (ndr_flags & NDR_SCALARS) {
11085                 NDR_CHECK(ndr_pull_align(ndr, 4));
11086                 {
11087                         uint32_t _flags_save_string = ndr->flags;
11088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11089                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
11090                         ndr->flags = _flags_save_string;
11091                 }
11092         }
11093         if (ndr_flags & NDR_BUFFERS) {
11094         }
11095         return NDR_ERR_SUCCESS;
11096 }
11097
11098 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11099 {
11100         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
11101         ndr->depth++;
11102         ndr_print_string(ndr, "directory_name", r->directory_name);
11103         ndr->depth--;
11104 }
11105
11106 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
11107 {
11108         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
11109 }
11110
11111 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
11112 {
11113         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11114         if (ndr_flags & NDR_SCALARS) {
11115                 int level = ndr_push_get_switch_value(ndr, r);
11116                 switch (level) {
11117                         case 1: {
11118                                 NDR_CHECK(ndr_push_align(ndr, 4));
11119                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11120                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11121                         break; }
11122
11123                         default: {
11124                         break; }
11125
11126                 }
11127         }
11128         if (ndr_flags & NDR_BUFFERS) {
11129                 int level = ndr_push_get_switch_value(ndr, r);
11130                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11131                 switch (level) {
11132                         case 1:
11133                         break;
11134
11135                         default:
11136                         break;
11137
11138                 }
11139         }
11140         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11141         return NDR_ERR_SUCCESS;
11142 }
11143
11144 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
11145 {
11146         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11147         int level;
11148         level = ndr_pull_get_switch_value(ndr, r);
11149         if (ndr_flags & NDR_SCALARS) {
11150                 switch (level) {
11151                         case 1: {
11152                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11153                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11154                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11155                         break; }
11156
11157                         default: {
11158                         break; }
11159
11160                 }
11161         }
11162         if (ndr_flags & NDR_BUFFERS) {
11163                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11164                 switch (level) {
11165                         case 1:
11166                         break;
11167
11168                         default:
11169                         break;
11170
11171                 }
11172         }
11173         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11174         return NDR_ERR_SUCCESS;
11175 }
11176
11177 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
11178 {
11179         int level;
11180         level = ndr_print_get_switch_value(ndr, r);
11181         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
11182         switch (level) {
11183                 case 1:
11184                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
11185                 break;
11186
11187                 default:
11188                 break;
11189
11190         }
11191 }
11192
11193 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11194 {
11195         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
11196 }
11197
11198 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
11199 {
11200         if (ndr_flags & NDR_SCALARS) {
11201                 NDR_CHECK(ndr_push_align(ndr, 4));
11202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
11203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
11204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
11205         }
11206         if (ndr_flags & NDR_BUFFERS) {
11207                 if (r->document_name) {
11208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11212                 }
11213                 if (r->output_file) {
11214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11215                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11217                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11218                 }
11219                 if (r->datatype) {
11220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11221                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11223                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11224                 }
11225         }
11226         return NDR_ERR_SUCCESS;
11227 }
11228
11229 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
11230 {
11231         uint32_t _ptr_document_name;
11232         TALLOC_CTX *_mem_save_document_name_0;
11233         uint32_t _ptr_output_file;
11234         TALLOC_CTX *_mem_save_output_file_0;
11235         uint32_t _ptr_datatype;
11236         TALLOC_CTX *_mem_save_datatype_0;
11237         if (ndr_flags & NDR_SCALARS) {
11238                 NDR_CHECK(ndr_pull_align(ndr, 4));
11239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
11240                 if (_ptr_document_name) {
11241                         NDR_PULL_ALLOC(ndr, r->document_name);
11242                 } else {
11243                         r->document_name = NULL;
11244                 }
11245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
11246                 if (_ptr_output_file) {
11247                         NDR_PULL_ALLOC(ndr, r->output_file);
11248                 } else {
11249                         r->output_file = NULL;
11250                 }
11251                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
11252                 if (_ptr_datatype) {
11253                         NDR_PULL_ALLOC(ndr, r->datatype);
11254                 } else {
11255                         r->datatype = NULL;
11256                 }
11257         }
11258         if (ndr_flags & NDR_BUFFERS) {
11259                 if (r->document_name) {
11260                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11261                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
11262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
11263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
11264                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
11265                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
11266                         }
11267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
11268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
11269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
11270                 }
11271                 if (r->output_file) {
11272                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11273                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
11274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
11275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
11276                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
11277                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->output_file), ndr_get_array_length(ndr, &r->output_file));
11278                         }
11279                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
11280                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
11281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
11282                 }
11283                 if (r->datatype) {
11284                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11285                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
11286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
11287                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
11288                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
11289                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
11290                         }
11291                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
11292                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
11293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
11294                 }
11295         }
11296         return NDR_ERR_SUCCESS;
11297 }
11298
11299 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
11300 {
11301         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
11302         ndr->depth++;
11303         ndr_print_ptr(ndr, "document_name", r->document_name);
11304         ndr->depth++;
11305         if (r->document_name) {
11306                 ndr_print_string(ndr, "document_name", r->document_name);
11307         }
11308         ndr->depth--;
11309         ndr_print_ptr(ndr, "output_file", r->output_file);
11310         ndr->depth++;
11311         if (r->output_file) {
11312                 ndr_print_string(ndr, "output_file", r->output_file);
11313         }
11314         ndr->depth--;
11315         ndr_print_ptr(ndr, "datatype", r->datatype);
11316         ndr->depth++;
11317         if (r->datatype) {
11318                 ndr_print_string(ndr, "datatype", r->datatype);
11319         }
11320         ndr->depth--;
11321         ndr->depth--;
11322 }
11323
11324 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
11325 {
11326         if (ndr_flags & NDR_SCALARS) {
11327                 int level = ndr_push_get_switch_value(ndr, r);
11328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11329                 switch (level) {
11330                         case 1: {
11331                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
11332                         break; }
11333
11334                         case 2: {
11335                         break; }
11336
11337                         case 3: {
11338                         break; }
11339
11340                         default: {
11341                         break; }
11342
11343                 }
11344         }
11345         if (ndr_flags & NDR_BUFFERS) {
11346                 int level = ndr_push_get_switch_value(ndr, r);
11347                 switch (level) {
11348                         case 1:
11349                                 if (r->info1) {
11350                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11351                                 }
11352                         break;
11353
11354                         case 2:
11355                         break;
11356
11357                         case 3:
11358                         break;
11359
11360                         default:
11361                         break;
11362
11363                 }
11364         }
11365         return NDR_ERR_SUCCESS;
11366 }
11367
11368 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
11369 {
11370         int level;
11371         uint32_t _level;
11372         TALLOC_CTX *_mem_save_info1_0;
11373         level = ndr_pull_get_switch_value(ndr, r);
11374         if (ndr_flags & NDR_SCALARS) {
11375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11376                 if (_level != level) {
11377                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11378                 }
11379                 switch (level) {
11380                         case 1: {
11381                                 uint32_t _ptr_info1;
11382                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
11383                                 if (_ptr_info1) {
11384                                         NDR_PULL_ALLOC(ndr, r->info1);
11385                                 } else {
11386                                         r->info1 = NULL;
11387                                 }
11388                         break; }
11389
11390                         case 2: {
11391                         break; }
11392
11393                         case 3: {
11394                         break; }
11395
11396                         default: {
11397                         break; }
11398
11399                 }
11400         }
11401         if (ndr_flags & NDR_BUFFERS) {
11402                 switch (level) {
11403                         case 1:
11404                                 if (r->info1) {
11405                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11406                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
11407                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11408                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
11409                                 }
11410                         break;
11411
11412                         case 2:
11413                         break;
11414
11415                         case 3:
11416                         break;
11417
11418                         default:
11419                         break;
11420
11421                 }
11422         }
11423         return NDR_ERR_SUCCESS;
11424 }
11425
11426 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
11427 {
11428         int level;
11429         level = ndr_print_get_switch_value(ndr, r);
11430         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
11431         switch (level) {
11432                 case 1:
11433                         ndr_print_ptr(ndr, "info1", r->info1);
11434                         ndr->depth++;
11435                         if (r->info1) {
11436                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
11437                         }
11438                         ndr->depth--;
11439                 break;
11440
11441                 case 2:
11442                 break;
11443
11444                 case 3:
11445                 break;
11446
11447                 default:
11448                 break;
11449
11450         }
11451 }
11452
11453 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
11454 {
11455         if (ndr_flags & NDR_SCALARS) {
11456                 NDR_CHECK(ndr_push_align(ndr, 4));
11457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
11458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11462                 {
11463                         uint32_t _flags_save_string = ndr->flags;
11464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11465                         {
11466                                 struct ndr_push *_ndr_extra_string;
11467                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11468                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11469                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11470                         }
11471                         ndr->flags = _flags_save_string;
11472                 }
11473         }
11474         if (ndr_flags & NDR_BUFFERS) {
11475         }
11476         return NDR_ERR_SUCCESS;
11477 }
11478
11479 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
11480 {
11481         if (ndr_flags & NDR_SCALARS) {
11482                 NDR_CHECK(ndr_pull_align(ndr, 4));
11483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
11488                 {
11489                         uint32_t _flags_save_string = ndr->flags;
11490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11491                         {
11492                                 struct ndr_pull *_ndr_extra_string;
11493                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11494                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11495                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11496                         }
11497                         ndr->flags = _flags_save_string;
11498                 }
11499         }
11500         if (ndr_flags & NDR_BUFFERS) {
11501         }
11502         return NDR_ERR_SUCCESS;
11503 }
11504
11505 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
11506 {
11507         ndr_print_struct(ndr, name, "spoolss_OSVersion");
11508         ndr->depth++;
11509         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
11510         ndr_print_uint32(ndr, "major", r->major);
11511         ndr_print_uint32(ndr, "minor", r->minor);
11512         ndr_print_uint32(ndr, "build", r->build);
11513         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
11514         ndr_print_string(ndr, "extra_string", r->extra_string);
11515         ndr->depth--;
11516 }
11517
11518 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
11519 {
11520         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
11521 }
11522
11523 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
11524 {
11525         if (ndr_flags & NDR_SCALARS) {
11526                 NDR_CHECK(ndr_push_align(ndr, 4));
11527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
11528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11532                 {
11533                         uint32_t _flags_save_string = ndr->flags;
11534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11535                         {
11536                                 struct ndr_push *_ndr_extra_string;
11537                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11538                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11539                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11540                         }
11541                         ndr->flags = _flags_save_string;
11542                 }
11543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
11544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
11545         }
11546         if (ndr_flags & NDR_BUFFERS) {
11547         }
11548         return NDR_ERR_SUCCESS;
11549 }
11550
11551 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
11552 {
11553         if (ndr_flags & NDR_SCALARS) {
11554                 NDR_CHECK(ndr_pull_align(ndr, 4));
11555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
11560                 {
11561                         uint32_t _flags_save_string = ndr->flags;
11562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11563                         {
11564                                 struct ndr_pull *_ndr_extra_string;
11565                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11566                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11567                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11568                         }
11569                         ndr->flags = _flags_save_string;
11570                 }
11571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
11572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
11573         }
11574         if (ndr_flags & NDR_BUFFERS) {
11575         }
11576         return NDR_ERR_SUCCESS;
11577 }
11578
11579 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
11580 {
11581         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
11582         ndr->depth++;
11583         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
11584         ndr_print_uint32(ndr, "major", r->major);
11585         ndr_print_uint32(ndr, "minor", r->minor);
11586         ndr_print_uint32(ndr, "build", r->build);
11587         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
11588         ndr_print_string(ndr, "extra_string", r->extra_string);
11589         ndr_print_uint32(ndr, "unknown2", r->unknown2);
11590         ndr_print_uint32(ndr, "unknown3", r->unknown3);
11591         ndr->depth--;
11592 }
11593
11594 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
11595 {
11596         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
11597 }
11598
11599 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
11600 {
11601         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11602         return NDR_ERR_SUCCESS;
11603 }
11604
11605 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
11606 {
11607         uint32_t v;
11608         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11609         *r = v;
11610         return NDR_ERR_SUCCESS;
11611 }
11612
11613 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
11614 {
11615         const char *val = NULL;
11616
11617         switch (r) {
11618                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
11619                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
11620                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
11621                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
11622                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
11623         }
11624         ndr_print_enum(ndr, name, "ENUM", val, r);
11625 }
11626
11627 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
11628 {
11629         if (ndr_flags & NDR_SCALARS) {
11630                 int level = ndr_push_get_switch_value(ndr, r);
11631                 switch (level) {
11632                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11633                         break; }
11634
11635                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11636                                 {
11637                                         uint32_t _flags_save_string = ndr->flags;
11638                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11639                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
11640                                         ndr->flags = _flags_save_string;
11641                                 }
11642                         break; }
11643
11644                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11645                                 {
11646                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11647                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11648                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11649                                         ndr->flags = _flags_save_DATA_BLOB;
11650                                 }
11651                         break; }
11652
11653                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11654                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
11655                         break; }
11656
11657                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11658                                 {
11659                                         uint32_t _flags_save_string_array = ndr->flags;
11660                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11661                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
11662                                         ndr->flags = _flags_save_string_array;
11663                                 }
11664                         break; }
11665
11666                         default: {
11667                                 {
11668                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11669                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11670                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
11671                                         ndr->flags = _flags_save_DATA_BLOB;
11672                                 }
11673                         break; }
11674
11675                 }
11676         }
11677         if (ndr_flags & NDR_BUFFERS) {
11678                 int level = ndr_push_get_switch_value(ndr, r);
11679                 switch (level) {
11680                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11681                         break;
11682
11683                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11684                         break;
11685
11686                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11687                         break;
11688
11689                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11690                         break;
11691
11692                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11693                         break;
11694
11695                         default:
11696                         break;
11697
11698                 }
11699         }
11700         return NDR_ERR_SUCCESS;
11701 }
11702
11703 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
11704 {
11705         int level;
11706         level = ndr_pull_get_switch_value(ndr, r);
11707         if (ndr_flags & NDR_SCALARS) {
11708                 switch (level) {
11709                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11710                         break; }
11711
11712                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11713                                 {
11714                                         uint32_t _flags_save_string = ndr->flags;
11715                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11716                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
11717                                         ndr->flags = _flags_save_string;
11718                                 }
11719                         break; }
11720
11721                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11722                                 {
11723                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11724                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11725                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
11726                                         ndr->flags = _flags_save_DATA_BLOB;
11727                                 }
11728                         break; }
11729
11730                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11731                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
11732                         break; }
11733
11734                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11735                                 {
11736                                         uint32_t _flags_save_string_array = ndr->flags;
11737                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11738                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
11739                                         ndr->flags = _flags_save_string_array;
11740                                 }
11741                         break; }
11742
11743                         default: {
11744                                 {
11745                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11746                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11747                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
11748                                         ndr->flags = _flags_save_DATA_BLOB;
11749                                 }
11750                         break; }
11751
11752                 }
11753         }
11754         if (ndr_flags & NDR_BUFFERS) {
11755                 switch (level) {
11756                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11757                         break;
11758
11759                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11760                         break;
11761
11762                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11763                         break;
11764
11765                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11766                         break;
11767
11768                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11769                         break;
11770
11771                         default:
11772                         break;
11773
11774                 }
11775         }
11776         return NDR_ERR_SUCCESS;
11777 }
11778
11779 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
11780 {
11781         int level;
11782         level = ndr_print_get_switch_value(ndr, r);
11783         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
11784         switch (level) {
11785                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11786                 break;
11787
11788                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11789                         ndr_print_string(ndr, "string", r->string);
11790                 break;
11791
11792                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11793                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
11794                 break;
11795
11796                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11797                         ndr_print_uint32(ndr, "value", r->value);
11798                 break;
11799
11800                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11801                         ndr_print_string_array(ndr, "string_array", r->string_array);
11802                 break;
11803
11804                 default:
11805                         ndr_print_DATA_BLOB(ndr, "data", r->data);
11806                 break;
11807
11808         }
11809 }
11810
11811 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11812 {
11813         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
11814 }
11815
11816 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
11817 {
11818         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11819         return NDR_ERR_SUCCESS;
11820 }
11821
11822 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
11823 {
11824         uint32_t v;
11825         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11826         *r = v;
11827         return NDR_ERR_SUCCESS;
11828 }
11829
11830 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
11831 {
11832         const char *val = NULL;
11833
11834         switch (r) {
11835                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
11836                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
11837                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
11838         }
11839         ndr_print_enum(ndr, name, "ENUM", val, r);
11840 }
11841
11842 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
11843 {
11844         if (ndr_flags & NDR_SCALARS) {
11845                 NDR_CHECK(ndr_push_align(ndr, 4));
11846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
11847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
11848         }
11849         if (ndr_flags & NDR_BUFFERS) {
11850         }
11851         return NDR_ERR_SUCCESS;
11852 }
11853
11854 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
11855 {
11856         if (ndr_flags & NDR_SCALARS) {
11857                 NDR_CHECK(ndr_pull_align(ndr, 4));
11858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
11859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
11860         }
11861         if (ndr_flags & NDR_BUFFERS) {
11862         }
11863         return NDR_ERR_SUCCESS;
11864 }
11865
11866 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
11867 {
11868         ndr_print_struct(ndr, name, "spoolss_FormSize");
11869         ndr->depth++;
11870         ndr_print_uint32(ndr, "width", r->width);
11871         ndr_print_uint32(ndr, "height", r->height);
11872         ndr->depth--;
11873 }
11874
11875 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
11876 {
11877         if (ndr_flags & NDR_SCALARS) {
11878                 NDR_CHECK(ndr_push_align(ndr, 4));
11879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
11880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
11881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
11882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
11883         }
11884         if (ndr_flags & NDR_BUFFERS) {
11885         }
11886         return NDR_ERR_SUCCESS;
11887 }
11888
11889 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
11890 {
11891         if (ndr_flags & NDR_SCALARS) {
11892                 NDR_CHECK(ndr_pull_align(ndr, 4));
11893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
11894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
11895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
11896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
11897         }
11898         if (ndr_flags & NDR_BUFFERS) {
11899         }
11900         return NDR_ERR_SUCCESS;
11901 }
11902
11903 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
11904 {
11905         ndr_print_struct(ndr, name, "spoolss_FormArea");
11906         ndr->depth++;
11907         ndr_print_uint32(ndr, "left", r->left);
11908         ndr_print_uint32(ndr, "top", r->top);
11909         ndr_print_uint32(ndr, "right", r->right);
11910         ndr_print_uint32(ndr, "bottom", r->bottom);
11911         ndr->depth--;
11912 }
11913
11914 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
11915 {
11916         if (ndr_flags & NDR_SCALARS) {
11917                 NDR_CHECK(ndr_push_align(ndr, 4));
11918                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
11919                 {
11920                         uint32_t _flags_save_string = ndr->flags;
11921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11922                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
11923                         ndr->flags = _flags_save_string;
11924                 }
11925                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11926                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11927         }
11928         if (ndr_flags & NDR_BUFFERS) {
11929                 {
11930                         uint32_t _flags_save_string = ndr->flags;
11931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11932                         if (r->form_name) {
11933                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
11934                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
11935                         }
11936                         ndr->flags = _flags_save_string;
11937                 }
11938         }
11939         return NDR_ERR_SUCCESS;
11940 }
11941
11942 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
11943 {
11944         uint32_t _ptr_form_name;
11945         TALLOC_CTX *_mem_save_form_name_0;
11946         if (ndr_flags & NDR_SCALARS) {
11947                 NDR_CHECK(ndr_pull_align(ndr, 4));
11948                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
11949                 {
11950                         uint32_t _flags_save_string = ndr->flags;
11951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11952                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
11953                         if (_ptr_form_name) {
11954                                 NDR_PULL_ALLOC(ndr, r->form_name);
11955                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
11956                         } else {
11957                                 r->form_name = NULL;
11958                         }
11959                         ndr->flags = _flags_save_string;
11960                 }
11961                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11962                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11963         }
11964         if (ndr_flags & NDR_BUFFERS) {
11965                 {
11966                         uint32_t _flags_save_string = ndr->flags;
11967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11968                         if (r->form_name) {
11969                                 uint32_t _relative_save_offset;
11970                                 _relative_save_offset = ndr->offset;
11971                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
11972                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11973                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
11974                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
11975                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
11976                                 ndr->offset = _relative_save_offset;
11977                         }
11978                         ndr->flags = _flags_save_string;
11979                 }
11980         }
11981         return NDR_ERR_SUCCESS;
11982 }
11983
11984 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
11985 {
11986         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
11987         ndr->depth++;
11988         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
11989         ndr_print_ptr(ndr, "form_name", r->form_name);
11990         ndr->depth++;
11991         if (r->form_name) {
11992                 ndr_print_string(ndr, "form_name", r->form_name);
11993         }
11994         ndr->depth--;
11995         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
11996         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
11997         ndr->depth--;
11998 }
11999
12000 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
12001 {
12002         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12003         if (ndr_flags & NDR_SCALARS) {
12004                 int level = ndr_push_get_switch_value(ndr, r);
12005                 switch (level) {
12006                         case 1: {
12007                                 NDR_CHECK(ndr_push_align(ndr, 4));
12008                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12009                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12010                         break; }
12011
12012                         default: {
12013                         break; }
12014
12015                 }
12016         }
12017         if (ndr_flags & NDR_BUFFERS) {
12018                 int level = ndr_push_get_switch_value(ndr, r);
12019                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12020                 switch (level) {
12021                         case 1:
12022                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12023                         break;
12024
12025                         default:
12026                         break;
12027
12028                 }
12029         }
12030         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12031         return NDR_ERR_SUCCESS;
12032 }
12033
12034 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
12035 {
12036         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12037         int level;
12038         level = ndr_pull_get_switch_value(ndr, r);
12039         if (ndr_flags & NDR_SCALARS) {
12040                 switch (level) {
12041                         case 1: {
12042                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12043                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12044                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12045                         break; }
12046
12047                         default: {
12048                         break; }
12049
12050                 }
12051         }
12052         if (ndr_flags & NDR_BUFFERS) {
12053                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12054                 switch (level) {
12055                         case 1:
12056                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12057                         break;
12058
12059                         default:
12060                         break;
12061
12062                 }
12063         }
12064         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12065         return NDR_ERR_SUCCESS;
12066 }
12067
12068 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
12069 {
12070         int level;
12071         level = ndr_print_get_switch_value(ndr, r);
12072         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
12073         switch (level) {
12074                 case 1:
12075                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
12076                 break;
12077
12078                 default:
12079                 break;
12080
12081         }
12082 }
12083
12084 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12085 {
12086         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
12087 }
12088
12089 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
12090 {
12091         if (ndr_flags & NDR_SCALARS) {
12092                 NDR_CHECK(ndr_push_align(ndr, 4));
12093                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
12094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
12095                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12096                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12097         }
12098         if (ndr_flags & NDR_BUFFERS) {
12099                 if (r->form_name) {
12100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12104                 }
12105         }
12106         return NDR_ERR_SUCCESS;
12107 }
12108
12109 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
12110 {
12111         uint32_t _ptr_form_name;
12112         TALLOC_CTX *_mem_save_form_name_0;
12113         if (ndr_flags & NDR_SCALARS) {
12114                 NDR_CHECK(ndr_pull_align(ndr, 4));
12115                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
12116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
12117                 if (_ptr_form_name) {
12118                         NDR_PULL_ALLOC(ndr, r->form_name);
12119                 } else {
12120                         r->form_name = NULL;
12121                 }
12122                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12123                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12124         }
12125         if (ndr_flags & NDR_BUFFERS) {
12126                 if (r->form_name) {
12127                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12128                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12129                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
12130                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
12131                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
12132                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
12133                         }
12134                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
12135                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
12136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12137                 }
12138         }
12139         return NDR_ERR_SUCCESS;
12140 }
12141
12142 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
12143 {
12144         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
12145         ndr->depth++;
12146         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12147         ndr_print_ptr(ndr, "form_name", r->form_name);
12148         ndr->depth++;
12149         if (r->form_name) {
12150                 ndr_print_string(ndr, "form_name", r->form_name);
12151         }
12152         ndr->depth--;
12153         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12154         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12155         ndr->depth--;
12156 }
12157
12158 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
12159 {
12160         if (ndr_flags & NDR_SCALARS) {
12161                 int level = ndr_push_get_switch_value(ndr, r);
12162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12163                 switch (level) {
12164                         case 1: {
12165                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
12166                         break; }
12167
12168                         default:
12169                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12170                 }
12171         }
12172         if (ndr_flags & NDR_BUFFERS) {
12173                 int level = ndr_push_get_switch_value(ndr, r);
12174                 switch (level) {
12175                         case 1:
12176                                 if (r->info1) {
12177                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12178                                 }
12179                         break;
12180
12181                         default:
12182                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12183                 }
12184         }
12185         return NDR_ERR_SUCCESS;
12186 }
12187
12188 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
12189 {
12190         int level;
12191         uint32_t _level;
12192         TALLOC_CTX *_mem_save_info1_0;
12193         level = ndr_pull_get_switch_value(ndr, r);
12194         if (ndr_flags & NDR_SCALARS) {
12195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12196                 if (_level != level) {
12197                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12198                 }
12199                 switch (level) {
12200                         case 1: {
12201                                 uint32_t _ptr_info1;
12202                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
12203                                 if (_ptr_info1) {
12204                                         NDR_PULL_ALLOC(ndr, r->info1);
12205                                 } else {
12206                                         r->info1 = NULL;
12207                                 }
12208                         break; }
12209
12210                         default:
12211                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12212                 }
12213         }
12214         if (ndr_flags & NDR_BUFFERS) {
12215                 switch (level) {
12216                         case 1:
12217                                 if (r->info1) {
12218                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12219                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
12220                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12221                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
12222                                 }
12223                         break;
12224
12225                         default:
12226                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12227                 }
12228         }
12229         return NDR_ERR_SUCCESS;
12230 }
12231
12232 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
12233 {
12234         int level;
12235         level = ndr_print_get_switch_value(ndr, r);
12236         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
12237         switch (level) {
12238                 case 1:
12239                         ndr_print_ptr(ndr, "info1", r->info1);
12240                         ndr->depth++;
12241                         if (r->info1) {
12242                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
12243                         }
12244                         ndr->depth--;
12245                 break;
12246
12247                 default:
12248                         ndr_print_bad_level(ndr, name, level);
12249         }
12250 }
12251
12252 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
12253 {
12254         if (ndr_flags & NDR_SCALARS) {
12255                 NDR_CHECK(ndr_push_align(ndr, 4));
12256                 {
12257                         uint32_t _flags_save_string = ndr->flags;
12258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12260                         ndr->flags = _flags_save_string;
12261                 }
12262         }
12263         if (ndr_flags & NDR_BUFFERS) {
12264                 {
12265                         uint32_t _flags_save_string = ndr->flags;
12266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12267                         if (r->port_name) {
12268                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12269                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12270                         }
12271                         ndr->flags = _flags_save_string;
12272                 }
12273         }
12274         return NDR_ERR_SUCCESS;
12275 }
12276
12277 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
12278 {
12279         uint32_t _ptr_port_name;
12280         TALLOC_CTX *_mem_save_port_name_0;
12281         if (ndr_flags & NDR_SCALARS) {
12282                 NDR_CHECK(ndr_pull_align(ndr, 4));
12283                 {
12284                         uint32_t _flags_save_string = ndr->flags;
12285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12287                         if (_ptr_port_name) {
12288                                 NDR_PULL_ALLOC(ndr, r->port_name);
12289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12290                         } else {
12291                                 r->port_name = NULL;
12292                         }
12293                         ndr->flags = _flags_save_string;
12294                 }
12295         }
12296         if (ndr_flags & NDR_BUFFERS) {
12297                 {
12298                         uint32_t _flags_save_string = ndr->flags;
12299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12300                         if (r->port_name) {
12301                                 uint32_t _relative_save_offset;
12302                                 _relative_save_offset = ndr->offset;
12303                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12304                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12305                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12306                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12307                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12308                                 ndr->offset = _relative_save_offset;
12309                         }
12310                         ndr->flags = _flags_save_string;
12311                 }
12312         }
12313         return NDR_ERR_SUCCESS;
12314 }
12315
12316 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
12317 {
12318         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
12319         ndr->depth++;
12320         ndr_print_ptr(ndr, "port_name", r->port_name);
12321         ndr->depth++;
12322         if (r->port_name) {
12323                 ndr_print_string(ndr, "port_name", r->port_name);
12324         }
12325         ndr->depth--;
12326         ndr->depth--;
12327 }
12328
12329 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12330 {
12331         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12332         return NDR_ERR_SUCCESS;
12333 }
12334
12335 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12336 {
12337         uint32_t v;
12338         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12339         *r = v;
12340         return NDR_ERR_SUCCESS;
12341 }
12342
12343 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
12344 {
12345         ndr_print_uint32(ndr, name, r);
12346         ndr->depth++;
12347         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
12348         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
12349         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
12350         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
12351         ndr->depth--;
12352 }
12353
12354 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
12355 {
12356         if (ndr_flags & NDR_SCALARS) {
12357                 NDR_CHECK(ndr_push_align(ndr, 4));
12358                 {
12359                         uint32_t _flags_save_string = ndr->flags;
12360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12361                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12362                         ndr->flags = _flags_save_string;
12363                 }
12364                 {
12365                         uint32_t _flags_save_string = ndr->flags;
12366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12367                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12368                         ndr->flags = _flags_save_string;
12369                 }
12370                 {
12371                         uint32_t _flags_save_string = ndr->flags;
12372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12373                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
12374                         ndr->flags = _flags_save_string;
12375                 }
12376                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
12377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12378         }
12379         if (ndr_flags & NDR_BUFFERS) {
12380                 {
12381                         uint32_t _flags_save_string = ndr->flags;
12382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12383                         if (r->port_name) {
12384                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12385                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12386                         }
12387                         ndr->flags = _flags_save_string;
12388                 }
12389                 {
12390                         uint32_t _flags_save_string = ndr->flags;
12391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12392                         if (r->monitor_name) {
12393                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12394                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12395                         }
12396                         ndr->flags = _flags_save_string;
12397                 }
12398                 {
12399                         uint32_t _flags_save_string = ndr->flags;
12400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12401                         if (r->description) {
12402                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
12403                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
12404                         }
12405                         ndr->flags = _flags_save_string;
12406                 }
12407         }
12408         return NDR_ERR_SUCCESS;
12409 }
12410
12411 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
12412 {
12413         uint32_t _ptr_port_name;
12414         TALLOC_CTX *_mem_save_port_name_0;
12415         uint32_t _ptr_monitor_name;
12416         TALLOC_CTX *_mem_save_monitor_name_0;
12417         uint32_t _ptr_description;
12418         TALLOC_CTX *_mem_save_description_0;
12419         if (ndr_flags & NDR_SCALARS) {
12420                 NDR_CHECK(ndr_pull_align(ndr, 4));
12421                 {
12422                         uint32_t _flags_save_string = ndr->flags;
12423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12424                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12425                         if (_ptr_port_name) {
12426                                 NDR_PULL_ALLOC(ndr, r->port_name);
12427                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12428                         } else {
12429                                 r->port_name = NULL;
12430                         }
12431                         ndr->flags = _flags_save_string;
12432                 }
12433                 {
12434                         uint32_t _flags_save_string = ndr->flags;
12435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12436                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12437                         if (_ptr_monitor_name) {
12438                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12439                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12440                         } else {
12441                                 r->monitor_name = NULL;
12442                         }
12443                         ndr->flags = _flags_save_string;
12444                 }
12445                 {
12446                         uint32_t _flags_save_string = ndr->flags;
12447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12448                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
12449                         if (_ptr_description) {
12450                                 NDR_PULL_ALLOC(ndr, r->description);
12451                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
12452                         } else {
12453                                 r->description = NULL;
12454                         }
12455                         ndr->flags = _flags_save_string;
12456                 }
12457                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
12458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12459         }
12460         if (ndr_flags & NDR_BUFFERS) {
12461                 {
12462                         uint32_t _flags_save_string = ndr->flags;
12463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12464                         if (r->port_name) {
12465                                 uint32_t _relative_save_offset;
12466                                 _relative_save_offset = ndr->offset;
12467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12468                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12469                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12472                                 ndr->offset = _relative_save_offset;
12473                         }
12474                         ndr->flags = _flags_save_string;
12475                 }
12476                 {
12477                         uint32_t _flags_save_string = ndr->flags;
12478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12479                         if (r->monitor_name) {
12480                                 uint32_t _relative_save_offset;
12481                                 _relative_save_offset = ndr->offset;
12482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12483                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12484                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12487                                 ndr->offset = _relative_save_offset;
12488                         }
12489                         ndr->flags = _flags_save_string;
12490                 }
12491                 {
12492                         uint32_t _flags_save_string = ndr->flags;
12493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12494                         if (r->description) {
12495                                 uint32_t _relative_save_offset;
12496                                 _relative_save_offset = ndr->offset;
12497                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
12498                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
12499                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
12500                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
12501                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
12502                                 ndr->offset = _relative_save_offset;
12503                         }
12504                         ndr->flags = _flags_save_string;
12505                 }
12506         }
12507         return NDR_ERR_SUCCESS;
12508 }
12509
12510 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
12511 {
12512         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
12513         ndr->depth++;
12514         ndr_print_ptr(ndr, "port_name", r->port_name);
12515         ndr->depth++;
12516         if (r->port_name) {
12517                 ndr_print_string(ndr, "port_name", r->port_name);
12518         }
12519         ndr->depth--;
12520         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12521         ndr->depth++;
12522         if (r->monitor_name) {
12523                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12524         }
12525         ndr->depth--;
12526         ndr_print_ptr(ndr, "description", r->description);
12527         ndr->depth++;
12528         if (r->description) {
12529                 ndr_print_string(ndr, "description", r->description);
12530         }
12531         ndr->depth--;
12532         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
12533         ndr_print_uint32(ndr, "reserved", r->reserved);
12534         ndr->depth--;
12535 }
12536
12537 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
12538 {
12539         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12540         if (ndr_flags & NDR_SCALARS) {
12541                 int level = ndr_push_get_switch_value(ndr, r);
12542                 switch (level) {
12543                         case 1: {
12544                                 NDR_CHECK(ndr_push_align(ndr, 4));
12545                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12546                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12547                         break; }
12548
12549                         case 2: {
12550                                 NDR_CHECK(ndr_push_align(ndr, 4));
12551                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12552                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12553                         break; }
12554
12555                         case 3: {
12556                         break; }
12557
12558                         default: {
12559                         break; }
12560
12561                 }
12562         }
12563         if (ndr_flags & NDR_BUFFERS) {
12564                 int level = ndr_push_get_switch_value(ndr, r);
12565                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12566                 switch (level) {
12567                         case 1:
12568                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12569                         break;
12570
12571                         case 2:
12572                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12573                         break;
12574
12575                         case 3:
12576                         break;
12577
12578                         default:
12579                         break;
12580
12581                 }
12582         }
12583         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12584         return NDR_ERR_SUCCESS;
12585 }
12586
12587 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
12588 {
12589         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12590         int level;
12591         level = ndr_pull_get_switch_value(ndr, r);
12592         if (ndr_flags & NDR_SCALARS) {
12593                 switch (level) {
12594                         case 1: {
12595                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12596                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12597                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12598                         break; }
12599
12600                         case 2: {
12601                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12602                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12603                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12604                         break; }
12605
12606                         case 3: {
12607                         break; }
12608
12609                         default: {
12610                         break; }
12611
12612                 }
12613         }
12614         if (ndr_flags & NDR_BUFFERS) {
12615                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12616                 switch (level) {
12617                         case 1:
12618                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12619                         break;
12620
12621                         case 2:
12622                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12623                         break;
12624
12625                         case 3:
12626                         break;
12627
12628                         default:
12629                         break;
12630
12631                 }
12632         }
12633         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12634         return NDR_ERR_SUCCESS;
12635 }
12636
12637 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
12638 {
12639         int level;
12640         level = ndr_print_get_switch_value(ndr, r);
12641         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
12642         switch (level) {
12643                 case 1:
12644                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
12645                 break;
12646
12647                 case 2:
12648                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
12649                 break;
12650
12651                 case 3:
12652                 break;
12653
12654                 default:
12655                 break;
12656
12657         }
12658 }
12659
12660 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
12661 {
12662         if (ndr_flags & NDR_SCALARS) {
12663                 NDR_CHECK(ndr_push_align(ndr, 4));
12664                 {
12665                         uint32_t _flags_save_string = ndr->flags;
12666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12667                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12668                         ndr->flags = _flags_save_string;
12669                 }
12670         }
12671         if (ndr_flags & NDR_BUFFERS) {
12672                 {
12673                         uint32_t _flags_save_string = ndr->flags;
12674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12675                         if (r->monitor_name) {
12676                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12678                         }
12679                         ndr->flags = _flags_save_string;
12680                 }
12681         }
12682         return NDR_ERR_SUCCESS;
12683 }
12684
12685 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
12686 {
12687         uint32_t _ptr_monitor_name;
12688         TALLOC_CTX *_mem_save_monitor_name_0;
12689         if (ndr_flags & NDR_SCALARS) {
12690                 NDR_CHECK(ndr_pull_align(ndr, 4));
12691                 {
12692                         uint32_t _flags_save_string = ndr->flags;
12693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12694                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12695                         if (_ptr_monitor_name) {
12696                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12697                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12698                         } else {
12699                                 r->monitor_name = NULL;
12700                         }
12701                         ndr->flags = _flags_save_string;
12702                 }
12703         }
12704         if (ndr_flags & NDR_BUFFERS) {
12705                 {
12706                         uint32_t _flags_save_string = ndr->flags;
12707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12708                         if (r->monitor_name) {
12709                                 uint32_t _relative_save_offset;
12710                                 _relative_save_offset = ndr->offset;
12711                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12712                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12713                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12714                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12715                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12716                                 ndr->offset = _relative_save_offset;
12717                         }
12718                         ndr->flags = _flags_save_string;
12719                 }
12720         }
12721         return NDR_ERR_SUCCESS;
12722 }
12723
12724 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
12725 {
12726         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
12727         ndr->depth++;
12728         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12729         ndr->depth++;
12730         if (r->monitor_name) {
12731                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12732         }
12733         ndr->depth--;
12734         ndr->depth--;
12735 }
12736
12737 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
12738 {
12739         if (ndr_flags & NDR_SCALARS) {
12740                 NDR_CHECK(ndr_push_align(ndr, 4));
12741                 {
12742                         uint32_t _flags_save_string = ndr->flags;
12743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12745                         ndr->flags = _flags_save_string;
12746                 }
12747                 {
12748                         uint32_t _flags_save_string = ndr->flags;
12749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
12751                         ndr->flags = _flags_save_string;
12752                 }
12753                 {
12754                         uint32_t _flags_save_string = ndr->flags;
12755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
12757                         ndr->flags = _flags_save_string;
12758                 }
12759         }
12760         if (ndr_flags & NDR_BUFFERS) {
12761                 {
12762                         uint32_t _flags_save_string = ndr->flags;
12763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12764                         if (r->monitor_name) {
12765                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12766                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12767                         }
12768                         ndr->flags = _flags_save_string;
12769                 }
12770                 {
12771                         uint32_t _flags_save_string = ndr->flags;
12772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12773                         if (r->environment) {
12774                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
12775                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
12776                         }
12777                         ndr->flags = _flags_save_string;
12778                 }
12779                 {
12780                         uint32_t _flags_save_string = ndr->flags;
12781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12782                         if (r->dll_name) {
12783                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
12784                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
12785                         }
12786                         ndr->flags = _flags_save_string;
12787                 }
12788         }
12789         return NDR_ERR_SUCCESS;
12790 }
12791
12792 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
12793 {
12794         uint32_t _ptr_monitor_name;
12795         TALLOC_CTX *_mem_save_monitor_name_0;
12796         uint32_t _ptr_environment;
12797         TALLOC_CTX *_mem_save_environment_0;
12798         uint32_t _ptr_dll_name;
12799         TALLOC_CTX *_mem_save_dll_name_0;
12800         if (ndr_flags & NDR_SCALARS) {
12801                 NDR_CHECK(ndr_pull_align(ndr, 4));
12802                 {
12803                         uint32_t _flags_save_string = ndr->flags;
12804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12805                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12806                         if (_ptr_monitor_name) {
12807                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12808                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12809                         } else {
12810                                 r->monitor_name = NULL;
12811                         }
12812                         ndr->flags = _flags_save_string;
12813                 }
12814                 {
12815                         uint32_t _flags_save_string = ndr->flags;
12816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12817                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
12818                         if (_ptr_environment) {
12819                                 NDR_PULL_ALLOC(ndr, r->environment);
12820                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
12821                         } else {
12822                                 r->environment = NULL;
12823                         }
12824                         ndr->flags = _flags_save_string;
12825                 }
12826                 {
12827                         uint32_t _flags_save_string = ndr->flags;
12828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12829                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
12830                         if (_ptr_dll_name) {
12831                                 NDR_PULL_ALLOC(ndr, r->dll_name);
12832                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
12833                         } else {
12834                                 r->dll_name = NULL;
12835                         }
12836                         ndr->flags = _flags_save_string;
12837                 }
12838         }
12839         if (ndr_flags & NDR_BUFFERS) {
12840                 {
12841                         uint32_t _flags_save_string = ndr->flags;
12842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12843                         if (r->monitor_name) {
12844                                 uint32_t _relative_save_offset;
12845                                 _relative_save_offset = ndr->offset;
12846                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12847                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12848                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12849                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12850                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12851                                 ndr->offset = _relative_save_offset;
12852                         }
12853                         ndr->flags = _flags_save_string;
12854                 }
12855                 {
12856                         uint32_t _flags_save_string = ndr->flags;
12857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12858                         if (r->environment) {
12859                                 uint32_t _relative_save_offset;
12860                                 _relative_save_offset = ndr->offset;
12861                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
12862                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
12863                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
12864                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
12865                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
12866                                 ndr->offset = _relative_save_offset;
12867                         }
12868                         ndr->flags = _flags_save_string;
12869                 }
12870                 {
12871                         uint32_t _flags_save_string = ndr->flags;
12872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12873                         if (r->dll_name) {
12874                                 uint32_t _relative_save_offset;
12875                                 _relative_save_offset = ndr->offset;
12876                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
12877                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12878                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
12879                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
12880                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
12881                                 ndr->offset = _relative_save_offset;
12882                         }
12883                         ndr->flags = _flags_save_string;
12884                 }
12885         }
12886         return NDR_ERR_SUCCESS;
12887 }
12888
12889 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
12890 {
12891         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
12892         ndr->depth++;
12893         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12894         ndr->depth++;
12895         if (r->monitor_name) {
12896                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12897         }
12898         ndr->depth--;
12899         ndr_print_ptr(ndr, "environment", r->environment);
12900         ndr->depth++;
12901         if (r->environment) {
12902                 ndr_print_string(ndr, "environment", r->environment);
12903         }
12904         ndr->depth--;
12905         ndr_print_ptr(ndr, "dll_name", r->dll_name);
12906         ndr->depth++;
12907         if (r->dll_name) {
12908                 ndr_print_string(ndr, "dll_name", r->dll_name);
12909         }
12910         ndr->depth--;
12911         ndr->depth--;
12912 }
12913
12914 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
12915 {
12916         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12917         if (ndr_flags & NDR_SCALARS) {
12918                 int level = ndr_push_get_switch_value(ndr, r);
12919                 switch (level) {
12920                         case 1: {
12921                                 NDR_CHECK(ndr_push_align(ndr, 4));
12922                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12923                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12924                         break; }
12925
12926                         case 2: {
12927                                 NDR_CHECK(ndr_push_align(ndr, 4));
12928                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12929                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12930                         break; }
12931
12932                         default: {
12933                         break; }
12934
12935                 }
12936         }
12937         if (ndr_flags & NDR_BUFFERS) {
12938                 int level = ndr_push_get_switch_value(ndr, r);
12939                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12940                 switch (level) {
12941                         case 1:
12942                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12943                         break;
12944
12945                         case 2:
12946                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12947                         break;
12948
12949                         default:
12950                         break;
12951
12952                 }
12953         }
12954         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12955         return NDR_ERR_SUCCESS;
12956 }
12957
12958 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
12959 {
12960         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12961         int level;
12962         level = ndr_pull_get_switch_value(ndr, r);
12963         if (ndr_flags & NDR_SCALARS) {
12964                 switch (level) {
12965                         case 1: {
12966                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12967                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12968                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12969                         break; }
12970
12971                         case 2: {
12972                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12973                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12974                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12975                         break; }
12976
12977                         default: {
12978                         break; }
12979
12980                 }
12981         }
12982         if (ndr_flags & NDR_BUFFERS) {
12983                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12984                 switch (level) {
12985                         case 1:
12986                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12987                         break;
12988
12989                         case 2:
12990                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12991                         break;
12992
12993                         default:
12994                         break;
12995
12996                 }
12997         }
12998         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12999         return NDR_ERR_SUCCESS;
13000 }
13001
13002 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
13003 {
13004         int level;
13005         level = ndr_print_get_switch_value(ndr, r);
13006         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
13007         switch (level) {
13008                 case 1:
13009                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
13010                 break;
13011
13012                 case 2:
13013                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
13014                 break;
13015
13016                 default:
13017                 break;
13018
13019         }
13020 }
13021
13022 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13023 {
13024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13025         return NDR_ERR_SUCCESS;
13026 }
13027
13028 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13029 {
13030         uint32_t v;
13031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13032         *r = v;
13033         return NDR_ERR_SUCCESS;
13034 }
13035
13036 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13037 {
13038         ndr_print_uint32(ndr, name, r);
13039         ndr->depth++;
13040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
13041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
13042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
13043         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
13044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
13045         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
13046         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
13047         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
13048         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
13049         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
13050         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
13051         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
13052         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
13053         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
13054         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
13055         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
13056         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
13057         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
13058         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
13059         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
13060         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
13061         ndr->depth--;
13062 }
13063
13064 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
13065 {
13066         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13067         return NDR_ERR_SUCCESS;
13068 }
13069
13070 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
13071 {
13072         uint16_t v;
13073         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13074         *r = v;
13075         return NDR_ERR_SUCCESS;
13076 }
13077
13078 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
13079 {
13080         const char *val = NULL;
13081
13082         switch (r) {
13083                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
13084                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
13085                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
13086                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
13087                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
13088                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
13089                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
13090                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
13091                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
13092                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
13093                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
13094                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
13095                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
13096                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
13097                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
13098                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
13099                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
13100                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
13101                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
13102                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
13103                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
13104                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
13105                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
13106                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
13107                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
13108                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
13109         }
13110         ndr_print_enum(ndr, name, "ENUM", val, r);
13111 }
13112
13113 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
13114 {
13115         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13116         return NDR_ERR_SUCCESS;
13117 }
13118
13119 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
13120 {
13121         uint16_t v;
13122         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13123         *r = v;
13124         return NDR_ERR_SUCCESS;
13125 }
13126
13127 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
13128 {
13129         const char *val = NULL;
13130
13131         switch (r) {
13132                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
13133                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
13134         }
13135         ndr_print_enum(ndr, name, "ENUM", val, r);
13136 }
13137
13138 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
13139 {
13140         uint32_t cntr_fields_1;
13141         if (ndr_flags & NDR_SCALARS) {
13142                 NDR_CHECK(ndr_push_align(ndr, 4));
13143                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13144                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
13145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
13146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
13147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
13149         }
13150         if (ndr_flags & NDR_BUFFERS) {
13151                 if (r->fields) {
13152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13153                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13154                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
13155                         }
13156                 }
13157         }
13158         return NDR_ERR_SUCCESS;
13159 }
13160
13161 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
13162 {
13163         uint32_t _ptr_fields;
13164         uint32_t cntr_fields_1;
13165         TALLOC_CTX *_mem_save_fields_0;
13166         TALLOC_CTX *_mem_save_fields_1;
13167         if (ndr_flags & NDR_SCALARS) {
13168                 NDR_CHECK(ndr_pull_align(ndr, 4));
13169                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13170                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
13171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
13172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
13173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
13175                 if (_ptr_fields) {
13176                         NDR_PULL_ALLOC(ndr, r->fields);
13177                 } else {
13178                         r->fields = NULL;
13179                 }
13180         }
13181         if (ndr_flags & NDR_BUFFERS) {
13182                 if (r->fields) {
13183                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
13184                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
13186                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
13187                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
13188                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13189                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13190                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
13191                         }
13192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
13193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
13194                 }
13195                 if (r->fields) {
13196                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
13197                 }
13198         }
13199         return NDR_ERR_SUCCESS;
13200 }
13201
13202 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
13203 {
13204         uint32_t cntr_fields_1;
13205         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
13206         ndr->depth++;
13207         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13208         ndr_print_uint16(ndr, "u1", r->u1);
13209         ndr_print_uint32(ndr, "u2", r->u2);
13210         ndr_print_uint32(ndr, "u3", r->u3);
13211         ndr_print_uint32(ndr, "count", r->count);
13212         ndr_print_ptr(ndr, "fields", r->fields);
13213         ndr->depth++;
13214         if (r->fields) {
13215                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
13216                 ndr->depth++;
13217                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
13218                         char *idx_1=NULL;
13219                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
13220                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
13221                                 free(idx_1);
13222                         }
13223                 }
13224                 ndr->depth--;
13225         }
13226         ndr->depth--;
13227         ndr->depth--;
13228 }
13229
13230 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13231 {
13232         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13233         return NDR_ERR_SUCCESS;
13234 }
13235
13236 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13237 {
13238         uint32_t v;
13239         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13240         *r = v;
13241         return NDR_ERR_SUCCESS;
13242 }
13243
13244 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13245 {
13246         ndr_print_uint32(ndr, name, r);
13247         ndr->depth++;
13248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
13249         ndr->depth--;
13250 }
13251
13252 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
13253 {
13254         uint32_t cntr_types_1;
13255         if (ndr_flags & NDR_SCALARS) {
13256                 NDR_CHECK(ndr_push_align(ndr, 4));
13257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13258                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
13259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
13261         }
13262         if (ndr_flags & NDR_BUFFERS) {
13263                 if (r->types) {
13264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13265                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13266                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13267                         }
13268                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13269                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13270                         }
13271                 }
13272         }
13273         return NDR_ERR_SUCCESS;
13274 }
13275
13276 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
13277 {
13278         uint32_t _ptr_types;
13279         uint32_t cntr_types_1;
13280         TALLOC_CTX *_mem_save_types_0;
13281         TALLOC_CTX *_mem_save_types_1;
13282         if (ndr_flags & NDR_SCALARS) {
13283                 NDR_CHECK(ndr_pull_align(ndr, 4));
13284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13285                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
13286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13287                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
13288                 if (_ptr_types) {
13289                         NDR_PULL_ALLOC(ndr, r->types);
13290                 } else {
13291                         r->types = NULL;
13292                 }
13293         }
13294         if (ndr_flags & NDR_BUFFERS) {
13295                 if (r->types) {
13296                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
13297                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13298                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
13299                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
13300                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
13301                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13302                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13303                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13304                         }
13305                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13306                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13307                         }
13308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
13309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
13310                 }
13311                 if (r->types) {
13312                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
13313                 }
13314         }
13315         return NDR_ERR_SUCCESS;
13316 }
13317
13318 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
13319 {
13320         uint32_t cntr_types_1;
13321         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
13322         ndr->depth++;
13323         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13324         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
13325         ndr_print_uint32(ndr, "count", r->count);
13326         ndr_print_ptr(ndr, "types", r->types);
13327         ndr->depth++;
13328         if (r->types) {
13329                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
13330                 ndr->depth++;
13331                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
13332                         char *idx_1=NULL;
13333                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
13334                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
13335                                 free(idx_1);
13336                         }
13337                 }
13338                 ndr->depth--;
13339         }
13340         ndr->depth--;
13341         ndr->depth--;
13342 }
13343
13344 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
13345 {
13346         if (ndr_flags & NDR_SCALARS) {
13347                 NDR_CHECK(ndr_push_align(ndr, 4));
13348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
13350         }
13351         if (ndr_flags & NDR_BUFFERS) {
13352                 if (r->string) {
13353                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
13354                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
13355                 }
13356         }
13357         return NDR_ERR_SUCCESS;
13358 }
13359
13360 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
13361 {
13362         uint32_t _ptr_string;
13363         TALLOC_CTX *_mem_save_string_0;
13364         if (ndr_flags & NDR_SCALARS) {
13365                 NDR_CHECK(ndr_pull_align(ndr, 4));
13366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13367                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
13368                 if (_ptr_string) {
13369                         NDR_PULL_ALLOC(ndr, r->string);
13370                 } else {
13371                         r->string = NULL;
13372                 }
13373         }
13374         if (ndr_flags & NDR_BUFFERS) {
13375                 if (r->string) {
13376                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
13377                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
13378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
13379                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
13380                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
13381                 }
13382                 if (r->string) {
13383                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
13384                 }
13385         }
13386         return NDR_ERR_SUCCESS;
13387 }
13388
13389 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
13390 {
13391         ndr_print_struct(ndr, name, "spoolss_NotifyString");
13392         ndr->depth++;
13393         ndr_print_uint32(ndr, "size", r->size);
13394         ndr_print_ptr(ndr, "string", r->string);
13395         ndr->depth++;
13396         if (r->string) {
13397                 ndr_print_string(ndr, "string", r->string);
13398         }
13399         ndr->depth--;
13400         ndr->depth--;
13401 }
13402
13403 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
13404 {
13405         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13406         return NDR_ERR_SUCCESS;
13407 }
13408
13409 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
13410 {
13411         uint32_t v;
13412         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13413         *r = v;
13414         return NDR_ERR_SUCCESS;
13415 }
13416
13417 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
13418 {
13419         const char *val = NULL;
13420
13421         switch (r) {
13422                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
13423                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
13424                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
13425                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
13426                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
13427         }
13428         ndr_print_enum(ndr, name, "ENUM", val, r);
13429 }
13430
13431 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
13432 {
13433         if (ndr_flags & NDR_SCALARS) {
13434                 int level = ndr_push_get_switch_value(ndr, r);
13435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13436                 switch (level) {
13437                         case 1: {
13438                                 uint32_t cntr_integer_0;
13439                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13440                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
13441                                 }
13442                         break; }
13443
13444                         case 2: {
13445                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13446                         break; }
13447
13448                         case 3: {
13449                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
13450                         break; }
13451
13452                         case 4: {
13453                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13454                         break; }
13455
13456                         case 5: {
13457                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13458                         break; }
13459
13460                         default:
13461                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13462                 }
13463         }
13464         if (ndr_flags & NDR_BUFFERS) {
13465                 int level = ndr_push_get_switch_value(ndr, r);
13466                 switch (level) {
13467                         case 1:
13468                         break;
13469
13470                         case 2:
13471                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13472                         break;
13473
13474                         case 3:
13475                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
13476                         break;
13477
13478                         case 4:
13479                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13480                         break;
13481
13482                         case 5:
13483                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13484                         break;
13485
13486                         default:
13487                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13488                 }
13489         }
13490         return NDR_ERR_SUCCESS;
13491 }
13492
13493 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
13494 {
13495         int level;
13496         uint32_t _level;
13497         level = ndr_pull_get_switch_value(ndr, r);
13498         if (ndr_flags & NDR_SCALARS) {
13499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13500                 if (_level != level) {
13501                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13502                 }
13503                 switch (level) {
13504                         case 1: {
13505                                 uint32_t cntr_integer_0;
13506                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13507                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
13508                                 }
13509                         break; }
13510
13511                         case 2: {
13512                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13513                         break; }
13514
13515                         case 3: {
13516                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
13517                         break; }
13518
13519                         case 4: {
13520                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13521                         break; }
13522
13523                         case 5: {
13524                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13525                         break; }
13526
13527                         default:
13528                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13529                 }
13530         }
13531         if (ndr_flags & NDR_BUFFERS) {
13532                 switch (level) {
13533                         case 1:
13534                         break;
13535
13536                         case 2:
13537                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13538                         break;
13539
13540                         case 3:
13541                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
13542                         break;
13543
13544                         case 4:
13545                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13546                         break;
13547
13548                         case 5:
13549                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13550                         break;
13551
13552                         default:
13553                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13554                 }
13555         }
13556         return NDR_ERR_SUCCESS;
13557 }
13558
13559 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
13560 {
13561         int level;
13562         uint32_t cntr_integer_0;
13563         level = ndr_print_get_switch_value(ndr, r);
13564         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
13565         switch (level) {
13566                 case 1:
13567                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
13568                         ndr->depth++;
13569                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
13570                                 char *idx_0=NULL;
13571                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
13572                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
13573                                         free(idx_0);
13574                                 }
13575                         }
13576                         ndr->depth--;
13577                 break;
13578
13579                 case 2:
13580                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
13581                 break;
13582
13583                 case 3:
13584                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
13585                 break;
13586
13587                 case 4:
13588                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
13589                 break;
13590
13591                 case 5:
13592                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
13593                 break;
13594
13595                 default:
13596                         ndr_print_bad_level(ndr, name, level);
13597         }
13598 }
13599
13600 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
13601 {
13602         if (ndr_flags & NDR_SCALARS) {
13603                 NDR_CHECK(ndr_push_align(ndr, 4));
13604                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13605                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
13606                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
13607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
13608                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
13609                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13610         }
13611         if (ndr_flags & NDR_BUFFERS) {
13612                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13613         }
13614         return NDR_ERR_SUCCESS;
13615 }
13616
13617 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
13618 {
13619         if (ndr_flags & NDR_SCALARS) {
13620                 NDR_CHECK(ndr_pull_align(ndr, 4));
13621                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13622                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
13623                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
13624                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
13625                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
13626                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13627         }
13628         if (ndr_flags & NDR_BUFFERS) {
13629                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13630         }
13631         return NDR_ERR_SUCCESS;
13632 }
13633
13634 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
13635 {
13636         ndr_print_struct(ndr, name, "spoolss_Notify");
13637         ndr->depth++;
13638         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13639         ndr_print_spoolss_Field(ndr, "field", r->field);
13640         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
13641         ndr_print_uint32(ndr, "job_id", r->job_id);
13642         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
13643         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
13644         ndr->depth--;
13645 }
13646
13647 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
13648 {
13649         uint32_t cntr_notifies_0;
13650         if (ndr_flags & NDR_SCALARS) {
13651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13652                 NDR_CHECK(ndr_push_align(ndr, 4));
13653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13656                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13657                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13658                 }
13659         }
13660         if (ndr_flags & NDR_BUFFERS) {
13661                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13662                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13663                 }
13664         }
13665         return NDR_ERR_SUCCESS;
13666 }
13667
13668 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
13669 {
13670         uint32_t cntr_notifies_0;
13671         TALLOC_CTX *_mem_save_notifies_0;
13672         if (ndr_flags & NDR_SCALARS) {
13673                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
13674                 NDR_CHECK(ndr_pull_align(ndr, 4));
13675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13678                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
13679                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13680                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13681                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13682                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13683                 }
13684                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13685                 if (r->notifies) {
13686                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
13687                 }
13688         }
13689         if (ndr_flags & NDR_BUFFERS) {
13690                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13691                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13692                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13693                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13694                 }
13695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13696         }
13697         return NDR_ERR_SUCCESS;
13698 }
13699
13700 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
13701 {
13702         uint32_t cntr_notifies_0;
13703         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
13704         ndr->depth++;
13705         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13706         ndr_print_uint32(ndr, "flags", r->flags);
13707         ndr_print_uint32(ndr, "count", r->count);
13708         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
13709         ndr->depth++;
13710         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
13711                 char *idx_0=NULL;
13712                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
13713                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
13714                         free(idx_0);
13715                 }
13716         }
13717         ndr->depth--;
13718         ndr->depth--;
13719 }
13720
13721 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
13722 {
13723         if (ndr_flags & NDR_SCALARS) {
13724                 int level = ndr_push_get_switch_value(ndr, r);
13725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13726                 switch (level) {
13727                         case 0: {
13728                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
13729                         break; }
13730
13731                         default:
13732                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13733                 }
13734         }
13735         if (ndr_flags & NDR_BUFFERS) {
13736                 int level = ndr_push_get_switch_value(ndr, r);
13737                 switch (level) {
13738                         case 0:
13739                                 if (r->info0) {
13740                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13741                                 }
13742                         break;
13743
13744                         default:
13745                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13746                 }
13747         }
13748         return NDR_ERR_SUCCESS;
13749 }
13750
13751 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
13752 {
13753         int level;
13754         uint32_t _level;
13755         TALLOC_CTX *_mem_save_info0_0;
13756         level = ndr_pull_get_switch_value(ndr, r);
13757         if (ndr_flags & NDR_SCALARS) {
13758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13759                 if (_level != level) {
13760                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13761                 }
13762                 switch (level) {
13763                         case 0: {
13764                                 uint32_t _ptr_info0;
13765                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
13766                                 if (_ptr_info0) {
13767                                         NDR_PULL_ALLOC(ndr, r->info0);
13768                                 } else {
13769                                         r->info0 = NULL;
13770                                 }
13771                         break; }
13772
13773                         default:
13774                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13775                 }
13776         }
13777         if (ndr_flags & NDR_BUFFERS) {
13778                 switch (level) {
13779                         case 0:
13780                                 if (r->info0) {
13781                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
13782                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
13783                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13784                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
13785                                 }
13786                         break;
13787
13788                         default:
13789                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13790                 }
13791         }
13792         return NDR_ERR_SUCCESS;
13793 }
13794
13795 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
13796 {
13797         int level;
13798         level = ndr_print_get_switch_value(ndr, r);
13799         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
13800         switch (level) {
13801                 case 0:
13802                         ndr_print_ptr(ndr, "info0", r->info0);
13803                         ndr->depth++;
13804                         if (r->info0) {
13805                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
13806                         }
13807                         ndr->depth--;
13808                 break;
13809
13810                 default:
13811                         ndr_print_bad_level(ndr, name, level);
13812         }
13813 }
13814
13815 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13816 {
13817         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13818         return NDR_ERR_SUCCESS;
13819 }
13820
13821 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13822 {
13823         uint32_t v;
13824         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13825         *r = v;
13826         return NDR_ERR_SUCCESS;
13827 }
13828
13829 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13830 {
13831         ndr_print_uint32(ndr, name, r);
13832         ndr->depth++;
13833         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
13834         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
13835         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
13836         ndr->depth--;
13837 }
13838
13839 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
13840 {
13841         if (ndr_flags & NDR_SCALARS) {
13842                 NDR_CHECK(ndr_push_align(ndr, 4));
13843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13844                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
13845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
13846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13847                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
13848                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
13849                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
13850         }
13851         if (ndr_flags & NDR_BUFFERS) {
13852                 if (r->client) {
13853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13855                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13856                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13857                 }
13858                 if (r->user) {
13859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13861                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13862                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13863                 }
13864         }
13865         return NDR_ERR_SUCCESS;
13866 }
13867
13868 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
13869 {
13870         uint32_t _ptr_client;
13871         TALLOC_CTX *_mem_save_client_0;
13872         uint32_t _ptr_user;
13873         TALLOC_CTX *_mem_save_user_0;
13874         if (ndr_flags & NDR_SCALARS) {
13875                 NDR_CHECK(ndr_pull_align(ndr, 4));
13876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
13878                 if (_ptr_client) {
13879                         NDR_PULL_ALLOC(ndr, r->client);
13880                 } else {
13881                         r->client = NULL;
13882                 }
13883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13884                 if (_ptr_user) {
13885                         NDR_PULL_ALLOC(ndr, r->user);
13886                 } else {
13887                         r->user = NULL;
13888                 }
13889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13890                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
13891                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
13892                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
13893         }
13894         if (ndr_flags & NDR_BUFFERS) {
13895                 if (r->client) {
13896                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
13897                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
13898                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
13899                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
13900                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
13901                                 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));
13902                         }
13903                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
13904                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
13905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
13906                 }
13907                 if (r->user) {
13908                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13909                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
13910                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
13911                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
13912                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
13913                                 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));
13914                         }
13915                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
13916                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
13917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13918                 }
13919         }
13920         return NDR_ERR_SUCCESS;
13921 }
13922
13923 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
13924 {
13925         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
13926         ndr->depth++;
13927         ndr_print_uint32(ndr, "size", r->size);
13928         ndr_print_ptr(ndr, "client", r->client);
13929         ndr->depth++;
13930         if (r->client) {
13931                 ndr_print_string(ndr, "client", r->client);
13932         }
13933         ndr->depth--;
13934         ndr_print_ptr(ndr, "user", r->user);
13935         ndr->depth++;
13936         if (r->user) {
13937                 ndr_print_string(ndr, "user", r->user);
13938         }
13939         ndr->depth--;
13940         ndr_print_uint32(ndr, "build", r->build);
13941         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
13942         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
13943         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
13944         ndr->depth--;
13945 }
13946
13947 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
13948 {
13949         if (ndr_flags & NDR_SCALARS) {
13950                 NDR_CHECK(ndr_push_align(ndr, 4));
13951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
13952         }
13953         if (ndr_flags & NDR_BUFFERS) {
13954         }
13955         return NDR_ERR_SUCCESS;
13956 }
13957
13958 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
13959 {
13960         if (ndr_flags & NDR_SCALARS) {
13961                 NDR_CHECK(ndr_pull_align(ndr, 4));
13962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
13963         }
13964         if (ndr_flags & NDR_BUFFERS) {
13965         }
13966         return NDR_ERR_SUCCESS;
13967 }
13968
13969 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
13970 {
13971         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
13972         ndr->depth++;
13973         ndr_print_uint32(ndr, "not_used", r->not_used);
13974         ndr->depth--;
13975 }
13976
13977 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
13978 {
13979         if (ndr_flags & NDR_SCALARS) {
13980                 NDR_CHECK(ndr_push_align(ndr, 4));
13981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
13984                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
13985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
13986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13987                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
13988                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
13989                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
13990                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
13991         }
13992         if (ndr_flags & NDR_BUFFERS) {
13993                 if (r->client) {
13994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13997                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13998                 }
13999                 if (r->user) {
14000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14001                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14003                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14004                 }
14005         }
14006         return NDR_ERR_SUCCESS;
14007 }
14008
14009 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
14010 {
14011         uint32_t _ptr_client;
14012         TALLOC_CTX *_mem_save_client_0;
14013         uint32_t _ptr_user;
14014         TALLOC_CTX *_mem_save_user_0;
14015         if (ndr_flags & NDR_SCALARS) {
14016                 NDR_CHECK(ndr_pull_align(ndr, 4));
14017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
14019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
14020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14021                 if (_ptr_client) {
14022                         NDR_PULL_ALLOC(ndr, r->client);
14023                 } else {
14024                         r->client = NULL;
14025                 }
14026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14027                 if (_ptr_user) {
14028                         NDR_PULL_ALLOC(ndr, r->user);
14029                 } else {
14030                         r->user = NULL;
14031                 }
14032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14033                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
14034                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
14035                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
14036                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
14037         }
14038         if (ndr_flags & NDR_BUFFERS) {
14039                 if (r->client) {
14040                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14041                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
14042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
14043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
14044                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
14045                                 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));
14046                         }
14047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
14048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
14049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14050                 }
14051                 if (r->user) {
14052                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14053                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
14054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
14055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
14056                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
14057                                 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));
14058                         }
14059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
14060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
14061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14062                 }
14063         }
14064         return NDR_ERR_SUCCESS;
14065 }
14066
14067 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
14068 {
14069         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
14070         ndr->depth++;
14071         ndr_print_uint32(ndr, "size", r->size);
14072         ndr_print_uint32(ndr, "flags", r->flags);
14073         ndr_print_uint32(ndr, "size2", r->size2);
14074         ndr_print_ptr(ndr, "client", r->client);
14075         ndr->depth++;
14076         if (r->client) {
14077                 ndr_print_string(ndr, "client", r->client);
14078         }
14079         ndr->depth--;
14080         ndr_print_ptr(ndr, "user", r->user);
14081         ndr->depth++;
14082         if (r->user) {
14083                 ndr_print_string(ndr, "user", r->user);
14084         }
14085         ndr->depth--;
14086         ndr_print_uint32(ndr, "build", r->build);
14087         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
14088         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
14089         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
14090         ndr_print_udlong(ndr, "reserved", r->reserved);
14091         ndr->depth--;
14092 }
14093
14094 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
14095 {
14096         if (ndr_flags & NDR_SCALARS) {
14097                 int level = ndr_push_get_switch_value(ndr, r);
14098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14099                 switch (level) {
14100                         case 1: {
14101                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
14102                         break; }
14103
14104                         case 2: {
14105                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
14106                         break; }
14107
14108                         case 3: {
14109                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
14110                         break; }
14111
14112                         default:
14113                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14114                 }
14115         }
14116         if (ndr_flags & NDR_BUFFERS) {
14117                 int level = ndr_push_get_switch_value(ndr, r);
14118                 switch (level) {
14119                         case 1:
14120                                 if (r->level1) {
14121                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14122                                 }
14123                         break;
14124
14125                         case 2:
14126                                 if (r->level2) {
14127                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14128                                 }
14129                         break;
14130
14131                         case 3:
14132                                 if (r->level3) {
14133                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14134                                 }
14135                         break;
14136
14137                         default:
14138                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14139                 }
14140         }
14141         return NDR_ERR_SUCCESS;
14142 }
14143
14144 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
14145 {
14146         int level;
14147         uint32_t _level;
14148         TALLOC_CTX *_mem_save_level1_0;
14149         TALLOC_CTX *_mem_save_level2_0;
14150         TALLOC_CTX *_mem_save_level3_0;
14151         level = ndr_pull_get_switch_value(ndr, r);
14152         if (ndr_flags & NDR_SCALARS) {
14153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14154                 if (_level != level) {
14155                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14156                 }
14157                 switch (level) {
14158                         case 1: {
14159                                 uint32_t _ptr_level1;
14160                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
14161                                 if (_ptr_level1) {
14162                                         NDR_PULL_ALLOC(ndr, r->level1);
14163                                 } else {
14164                                         r->level1 = NULL;
14165                                 }
14166                         break; }
14167
14168                         case 2: {
14169                                 uint32_t _ptr_level2;
14170                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
14171                                 if (_ptr_level2) {
14172                                         NDR_PULL_ALLOC(ndr, r->level2);
14173                                 } else {
14174                                         r->level2 = NULL;
14175                                 }
14176                         break; }
14177
14178                         case 3: {
14179                                 uint32_t _ptr_level3;
14180                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
14181                                 if (_ptr_level3) {
14182                                         NDR_PULL_ALLOC(ndr, r->level3);
14183                                 } else {
14184                                         r->level3 = NULL;
14185                                 }
14186                         break; }
14187
14188                         default:
14189                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14190                 }
14191         }
14192         if (ndr_flags & NDR_BUFFERS) {
14193                 switch (level) {
14194                         case 1:
14195                                 if (r->level1) {
14196                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14197                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
14198                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14199                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
14200                                 }
14201                         break;
14202
14203                         case 2:
14204                                 if (r->level2) {
14205                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
14206                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
14207                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14208                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
14209                                 }
14210                         break;
14211
14212                         case 3:
14213                                 if (r->level3) {
14214                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
14215                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
14216                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14217                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
14218                                 }
14219                         break;
14220
14221                         default:
14222                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14223                 }
14224         }
14225         return NDR_ERR_SUCCESS;
14226 }
14227
14228 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
14229 {
14230         int level;
14231         level = ndr_print_get_switch_value(ndr, r);
14232         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
14233         switch (level) {
14234                 case 1:
14235                         ndr_print_ptr(ndr, "level1", r->level1);
14236                         ndr->depth++;
14237                         if (r->level1) {
14238                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
14239                         }
14240                         ndr->depth--;
14241                 break;
14242
14243                 case 2:
14244                         ndr_print_ptr(ndr, "level2", r->level2);
14245                         ndr->depth++;
14246                         if (r->level2) {
14247                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
14248                         }
14249                         ndr->depth--;
14250                 break;
14251
14252                 case 3:
14253                         ndr_print_ptr(ndr, "level3", r->level3);
14254                         ndr->depth++;
14255                         if (r->level3) {
14256                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
14257                         }
14258                         ndr->depth--;
14259                 break;
14260
14261                 default:
14262                         ndr_print_bad_level(ndr, name, level);
14263         }
14264 }
14265
14266 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
14267 {
14268         if (ndr_flags & NDR_SCALARS) {
14269                 NDR_CHECK(ndr_push_align(ndr, 4));
14270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
14271                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
14272                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14273         }
14274         if (ndr_flags & NDR_BUFFERS) {
14275                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14276         }
14277         return NDR_ERR_SUCCESS;
14278 }
14279
14280 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
14281 {
14282         if (ndr_flags & NDR_SCALARS) {
14283                 NDR_CHECK(ndr_pull_align(ndr, 4));
14284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
14285                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
14286                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14287         }
14288         if (ndr_flags & NDR_BUFFERS) {
14289                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14290         }
14291         return NDR_ERR_SUCCESS;
14292 }
14293
14294 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
14295 {
14296         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
14297         ndr->depth++;
14298         ndr_print_uint32(ndr, "level", r->level);
14299         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
14300         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
14301         ndr->depth--;
14302 }
14303
14304 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14305 {
14306         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14307         return NDR_ERR_SUCCESS;
14308 }
14309
14310 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14311 {
14312         uint32_t v;
14313         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14314         *r = v;
14315         return NDR_ERR_SUCCESS;
14316 }
14317
14318 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
14319 {
14320         ndr_print_uint32(ndr, name, r);
14321         ndr->depth++;
14322         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
14323         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
14324         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
14325         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
14326         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
14327         ndr->depth--;
14328 }
14329
14330 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14331 {
14332         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14333         return NDR_ERR_SUCCESS;
14334 }
14335
14336 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14337 {
14338         uint32_t v;
14339         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14340         *r = v;
14341         return NDR_ERR_SUCCESS;
14342 }
14343
14344 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14345 {
14346         ndr_print_uint32(ndr, name, r);
14347         ndr->depth++;
14348         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
14349         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
14350         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
14351         ndr->depth--;
14352 }
14353
14354 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
14355 {
14356         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14357         return NDR_ERR_SUCCESS;
14358 }
14359
14360 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
14361 {
14362         uint32_t v;
14363         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14364         *r = v;
14365         return NDR_ERR_SUCCESS;
14366 }
14367
14368 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
14369 {
14370         const char *val = NULL;
14371
14372         switch (r) {
14373                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
14374                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
14375         }
14376         ndr_print_enum(ndr, name, "ENUM", val, r);
14377 }
14378
14379 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
14380 {
14381         if (ndr_flags & NDR_SCALARS) {
14382                 NDR_CHECK(ndr_push_align(ndr, 4));
14383                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
14385                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14388                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14389                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14391                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14392                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14393                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14394                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14398         }
14399         if (ndr_flags & NDR_BUFFERS) {
14400         }
14401         return NDR_ERR_SUCCESS;
14402 }
14403
14404 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
14405 {
14406         if (ndr_flags & NDR_SCALARS) {
14407                 NDR_CHECK(ndr_pull_align(ndr, 4));
14408                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14410                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14413                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14414                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14416                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14417                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14418                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14419                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14423         }
14424         if (ndr_flags & NDR_BUFFERS) {
14425         }
14426         return NDR_ERR_SUCCESS;
14427 }
14428
14429 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
14430 {
14431         ndr_print_struct(ndr, name, "spoolss_PortData1");
14432         ndr->depth++;
14433         ndr_print_string(ndr, "portname", r->portname);
14434         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
14435         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14436         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14437         ndr_print_uint32(ndr, "reserved", r->reserved);
14438         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14439         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14440         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14441         ndr_print_string(ndr, "queue", r->queue);
14442         ndr_print_string(ndr, "ip_address", r->ip_address);
14443         ndr_print_string(ndr, "hardware_address", r->hardware_address);
14444         ndr_print_string(ndr, "device_type", r->device_type);
14445         ndr_print_uint32(ndr, "port_number", r->port_number);
14446         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14447         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14448         ndr->depth--;
14449 }
14450
14451 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
14452 {
14453         if (ndr_flags & NDR_SCALARS) {
14454                 NDR_CHECK(ndr_push_align(ndr, 4));
14455                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
14457                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14460                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14461                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14463                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14464                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
14469         }
14470         if (ndr_flags & NDR_BUFFERS) {
14471         }
14472         return NDR_ERR_SUCCESS;
14473 }
14474
14475 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
14476 {
14477         if (ndr_flags & NDR_SCALARS) {
14478                 NDR_CHECK(ndr_pull_align(ndr, 4));
14479                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14481                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14484                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14485                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14487                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14488                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
14493         }
14494         if (ndr_flags & NDR_BUFFERS) {
14495         }
14496         return NDR_ERR_SUCCESS;
14497 }
14498
14499 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
14500 {
14501         ndr_print_struct(ndr, name, "spoolss_PortData2");
14502         ndr->depth++;
14503         ndr_print_string(ndr, "portname", r->portname);
14504         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
14505         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14506         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14507         ndr_print_uint32(ndr, "reserved", r->reserved);
14508         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14509         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14510         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14511         ndr_print_string(ndr, "queue", r->queue);
14512         ndr_print_string(ndr, "device_type", r->device_type);
14513         ndr_print_uint32(ndr, "port_number", r->port_number);
14514         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14515         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14516         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
14517         ndr->depth--;
14518 }
14519
14520 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
14521 {
14522         if (ndr_flags & NDR_SCALARS) {
14523                 NDR_CHECK(ndr_push_align(ndr, 4));
14524                 {
14525                         uint32_t _flags_save_string = ndr->flags;
14526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14527                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
14528                         ndr->flags = _flags_save_string;
14529                 }
14530         }
14531         if (ndr_flags & NDR_BUFFERS) {
14532         }
14533         return NDR_ERR_SUCCESS;
14534 }
14535
14536 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
14537 {
14538         if (ndr_flags & NDR_SCALARS) {
14539                 NDR_CHECK(ndr_pull_align(ndr, 4));
14540                 {
14541                         uint32_t _flags_save_string = ndr->flags;
14542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14543                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
14544                         ndr->flags = _flags_save_string;
14545                 }
14546         }
14547         if (ndr_flags & NDR_BUFFERS) {
14548         }
14549         return NDR_ERR_SUCCESS;
14550 }
14551
14552 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
14553 {
14554         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
14555         ndr->depth++;
14556         ndr_print_string(ndr, "dll_name", r->dll_name);
14557         ndr->depth--;
14558 }
14559
14560 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14561 {
14562         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14563         return NDR_ERR_SUCCESS;
14564 }
14565
14566 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14567 {
14568         uint32_t v;
14569         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14570         *r = v;
14571         return NDR_ERR_SUCCESS;
14572 }
14573
14574 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14575 {
14576         ndr_print_uint32(ndr, name, r);
14577         ndr->depth++;
14578         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
14579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
14580         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
14581         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
14582         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
14583         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
14584         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
14585         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
14586         ndr->depth--;
14587 }
14588
14589 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
14590 {
14591         if (flags & NDR_IN) {
14592                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
14593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14594                 if (r->in.server) {
14595                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14598                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14599                 }
14600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14602                 if (r->in.buffer) {
14603                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14604                 }
14605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14606         }
14607         if (flags & NDR_OUT) {
14608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14609                 if (r->out.info) {
14610                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
14611                 }
14612                 if (r->out.needed == NULL) {
14613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14614                 }
14615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14616                 if (r->out.count == NULL) {
14617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14618                 }
14619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
14620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14621         }
14622         return NDR_ERR_SUCCESS;
14623 }
14624
14625 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
14626 {
14627         uint32_t _ptr_server;
14628         uint32_t _ptr_buffer;
14629         uint32_t _ptr_info;
14630         TALLOC_CTX *_mem_save_server_0;
14631         TALLOC_CTX *_mem_save_buffer_0;
14632         TALLOC_CTX *_mem_save_info_0;
14633         TALLOC_CTX *_mem_save_needed_0;
14634         TALLOC_CTX *_mem_save_count_0;
14635         if (flags & NDR_IN) {
14636                 ZERO_STRUCT(r->out);
14637
14638                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
14639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14640                 if (_ptr_server) {
14641                         NDR_PULL_ALLOC(ndr, r->in.server);
14642                 } else {
14643                         r->in.server = NULL;
14644                 }
14645                 if (r->in.server) {
14646                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14647                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14648                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14649                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14650                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14651                                 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));
14652                         }
14653                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14654                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14655                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14656                 }
14657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14659                 if (_ptr_buffer) {
14660                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14661                 } else {
14662                         r->in.buffer = NULL;
14663                 }
14664                 if (r->in.buffer) {
14665                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14666                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14667                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14669                 }
14670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14671                 NDR_PULL_ALLOC(ndr, r->out.needed);
14672                 ZERO_STRUCTP(r->out.needed);
14673                 NDR_PULL_ALLOC(ndr, r->out.count);
14674                 ZERO_STRUCTP(r->out.count);
14675         }
14676         if (flags & NDR_OUT) {
14677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14678                 if (_ptr_info) {
14679                         NDR_PULL_ALLOC(ndr, r->out.info);
14680                 } else {
14681                         r->out.info = NULL;
14682                 }
14683                 if (r->out.info) {
14684                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14685                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14686                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
14687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14688                 }
14689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14690                         NDR_PULL_ALLOC(ndr, r->out.needed);
14691                 }
14692                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14693                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14697                         NDR_PULL_ALLOC(ndr, r->out.count);
14698                 }
14699                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
14700                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
14701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
14702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
14703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14704         }
14705         return NDR_ERR_SUCCESS;
14706 }
14707
14708 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
14709 {
14710         uint32_t cntr_info_0;
14711         if (flags & NDR_IN) {
14712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
14714         }
14715         if (flags & NDR_OUT) {
14716                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14717                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14718                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14719                 }
14720                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14721                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14722                 }
14723         }
14724         return NDR_ERR_SUCCESS;
14725 }
14726
14727 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
14728 {
14729         uint32_t cntr_info_0;
14730         TALLOC_CTX *_mem_save_info_0;
14731         if (flags & NDR_IN) {
14732                 ZERO_STRUCT(r->out);
14733
14734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
14736         }
14737         if (flags & NDR_OUT) {
14738                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
14739                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14740                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14741                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14742                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14743                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14744                 }
14745                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14746                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14747                 }
14748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14749         }
14750         return NDR_ERR_SUCCESS;
14751 }
14752
14753 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
14754 {
14755         uint32_t cntr_info_1;
14756         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
14757         ndr->depth++;
14758         if (flags & NDR_SET_VALUES) {
14759                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14760         }
14761         if (flags & NDR_IN) {
14762                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
14763                 ndr->depth++;
14764                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
14765                 ndr_print_ptr(ndr, "server", r->in.server);
14766                 ndr->depth++;
14767                 if (r->in.server) {
14768                         ndr_print_string(ndr, "server", r->in.server);
14769                 }
14770                 ndr->depth--;
14771                 ndr_print_uint32(ndr, "level", r->in.level);
14772                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14773                 ndr->depth++;
14774                 if (r->in.buffer) {
14775                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14776                 }
14777                 ndr->depth--;
14778                 ndr_print_uint32(ndr, "offered", r->in.offered);
14779                 ndr->depth--;
14780         }
14781         if (flags & NDR_OUT) {
14782                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
14783                 ndr->depth++;
14784                 ndr_print_ptr(ndr, "count", r->out.count);
14785                 ndr->depth++;
14786                 ndr_print_uint32(ndr, "count", *r->out.count);
14787                 ndr->depth--;
14788                 ndr_print_ptr(ndr, "info", r->out.info);
14789                 ndr->depth++;
14790                 if (r->out.info) {
14791                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
14792                         ndr->depth++;
14793                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
14794                                 char *idx_1=NULL;
14795                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
14796                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
14797                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
14798                                         free(idx_1);
14799                                 }
14800                         }
14801                         ndr->depth--;
14802                 }
14803                 ndr->depth--;
14804                 ndr_print_ptr(ndr, "needed", r->out.needed);
14805                 ndr->depth++;
14806                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14807                 ndr->depth--;
14808                 ndr_print_WERROR(ndr, "result", r->out.result);
14809                 ndr->depth--;
14810         }
14811         ndr->depth--;
14812 }
14813
14814 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
14815 {
14816         if (flags & NDR_IN) {
14817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
14818                 if (r->in.printername) {
14819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14822                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14823                 }
14824                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
14825                 if (r->in.datatype) {
14826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14830                 }
14831                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14832                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
14833         }
14834         if (flags & NDR_OUT) {
14835                 if (r->out.handle == NULL) {
14836                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14837                 }
14838                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14839                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14840         }
14841         return NDR_ERR_SUCCESS;
14842 }
14843
14844 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
14845 {
14846         uint32_t _ptr_printername;
14847         uint32_t _ptr_datatype;
14848         TALLOC_CTX *_mem_save_printername_0;
14849         TALLOC_CTX *_mem_save_datatype_0;
14850         TALLOC_CTX *_mem_save_handle_0;
14851         if (flags & NDR_IN) {
14852                 ZERO_STRUCT(r->out);
14853
14854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
14855                 if (_ptr_printername) {
14856                         NDR_PULL_ALLOC(ndr, r->in.printername);
14857                 } else {
14858                         r->in.printername = NULL;
14859                 }
14860                 if (r->in.printername) {
14861                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
14862                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
14863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
14864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
14865                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
14866                                 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));
14867                         }
14868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
14869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
14870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
14871                 }
14872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14873                 if (_ptr_datatype) {
14874                         NDR_PULL_ALLOC(ndr, r->in.datatype);
14875                 } else {
14876                         r->in.datatype = NULL;
14877                 }
14878                 if (r->in.datatype) {
14879                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14880                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
14881                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
14882                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
14883                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
14884                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
14885                         }
14886                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
14887                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
14888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14889                 }
14890                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14891                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
14892                 NDR_PULL_ALLOC(ndr, r->out.handle);
14893                 ZERO_STRUCTP(r->out.handle);
14894         }
14895         if (flags & NDR_OUT) {
14896                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14897                         NDR_PULL_ALLOC(ndr, r->out.handle);
14898                 }
14899                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14900                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14901                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14903                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14904         }
14905         return NDR_ERR_SUCCESS;
14906 }
14907
14908 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
14909 {
14910         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
14911         ndr->depth++;
14912         if (flags & NDR_SET_VALUES) {
14913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14914         }
14915         if (flags & NDR_IN) {
14916                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
14917                 ndr->depth++;
14918                 ndr_print_ptr(ndr, "printername", r->in.printername);
14919                 ndr->depth++;
14920                 if (r->in.printername) {
14921                         ndr_print_string(ndr, "printername", r->in.printername);
14922                 }
14923                 ndr->depth--;
14924                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
14925                 ndr->depth++;
14926                 if (r->in.datatype) {
14927                         ndr_print_string(ndr, "datatype", r->in.datatype);
14928                 }
14929                 ndr->depth--;
14930                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
14931                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
14932                 ndr->depth--;
14933         }
14934         if (flags & NDR_OUT) {
14935                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
14936                 ndr->depth++;
14937                 ndr_print_ptr(ndr, "handle", r->out.handle);
14938                 ndr->depth++;
14939                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14940                 ndr->depth--;
14941                 ndr_print_WERROR(ndr, "result", r->out.result);
14942                 ndr->depth--;
14943         }
14944         ndr->depth--;
14945 }
14946
14947 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
14948 {
14949         if (flags & NDR_IN) {
14950                 if (r->in.handle == NULL) {
14951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14952                 }
14953                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
14955                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
14956                 if (r->in.ctr) {
14957                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14958                 }
14959                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
14960         }
14961         if (flags & NDR_OUT) {
14962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14963         }
14964         return NDR_ERR_SUCCESS;
14965 }
14966
14967 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
14968 {
14969         uint32_t _ptr_ctr;
14970         TALLOC_CTX *_mem_save_handle_0;
14971         TALLOC_CTX *_mem_save_ctr_0;
14972         if (flags & NDR_IN) {
14973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14974                         NDR_PULL_ALLOC(ndr, r->in.handle);
14975                 }
14976                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14977                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14978                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
14981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
14982                 if (_ptr_ctr) {
14983                         NDR_PULL_ALLOC(ndr, r->in.ctr);
14984                 } else {
14985                         r->in.ctr = NULL;
14986                 }
14987                 if (r->in.ctr) {
14988                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14989                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
14990                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
14992                 }
14993                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
14994         }
14995         if (flags & NDR_OUT) {
14996                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14997         }
14998         return NDR_ERR_SUCCESS;
14999 }
15000
15001 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
15002 {
15003         ndr_print_struct(ndr, name, "spoolss_SetJob");
15004         ndr->depth++;
15005         if (flags & NDR_SET_VALUES) {
15006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15007         }
15008         if (flags & NDR_IN) {
15009                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
15010                 ndr->depth++;
15011                 ndr_print_ptr(ndr, "handle", r->in.handle);
15012                 ndr->depth++;
15013                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15014                 ndr->depth--;
15015                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15016                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
15017                 ndr->depth++;
15018                 if (r->in.ctr) {
15019                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
15020                 }
15021                 ndr->depth--;
15022                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
15023                 ndr->depth--;
15024         }
15025         if (flags & NDR_OUT) {
15026                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
15027                 ndr->depth++;
15028                 ndr_print_WERROR(ndr, "result", r->out.result);
15029                 ndr->depth--;
15030         }
15031         ndr->depth--;
15032 }
15033
15034 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
15035 {
15036         if (flags & NDR_IN) {
15037                 if (r->in.handle == NULL) {
15038                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15039                 }
15040                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
15042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15044                 if (r->in.buffer) {
15045                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15046                 }
15047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15048         }
15049         if (flags & NDR_OUT) {
15050                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15051                 if (r->out.info) {
15052                         {
15053                                 struct ndr_push *_ndr_info;
15054                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15055                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15056                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15057                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15058                         }
15059                 }
15060                 if (r->out.needed == NULL) {
15061                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15062                 }
15063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15064                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15065         }
15066         return NDR_ERR_SUCCESS;
15067 }
15068
15069 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
15070 {
15071         uint32_t _ptr_buffer;
15072         uint32_t _ptr_info;
15073         TALLOC_CTX *_mem_save_handle_0;
15074         TALLOC_CTX *_mem_save_buffer_0;
15075         TALLOC_CTX *_mem_save_info_0;
15076         TALLOC_CTX *_mem_save_needed_0;
15077         if (flags & NDR_IN) {
15078                 ZERO_STRUCT(r->out);
15079
15080                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15081                         NDR_PULL_ALLOC(ndr, r->in.handle);
15082                 }
15083                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15084                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15085                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15086                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
15088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15090                 if (_ptr_buffer) {
15091                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15092                 } else {
15093                         r->in.buffer = NULL;
15094                 }
15095                 if (r->in.buffer) {
15096                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15097                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15098                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15100                 }
15101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15102                 NDR_PULL_ALLOC(ndr, r->out.needed);
15103                 ZERO_STRUCTP(r->out.needed);
15104         }
15105         if (flags & NDR_OUT) {
15106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15107                 if (_ptr_info) {
15108                         NDR_PULL_ALLOC(ndr, r->out.info);
15109                 } else {
15110                         r->out.info = NULL;
15111                 }
15112                 if (r->out.info) {
15113                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15114                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15115                         {
15116                                 struct ndr_pull *_ndr_info;
15117                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15118                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15119                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15120                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15121                         }
15122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15123                 }
15124                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15125                         NDR_PULL_ALLOC(ndr, r->out.needed);
15126                 }
15127                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15128                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15130                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15131                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15132         }
15133         return NDR_ERR_SUCCESS;
15134 }
15135
15136 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
15137 {
15138         ndr_print_struct(ndr, name, "spoolss_GetJob");
15139         ndr->depth++;
15140         if (flags & NDR_SET_VALUES) {
15141                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15142         }
15143         if (flags & NDR_IN) {
15144                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
15145                 ndr->depth++;
15146                 ndr_print_ptr(ndr, "handle", r->in.handle);
15147                 ndr->depth++;
15148                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15149                 ndr->depth--;
15150                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15151                 ndr_print_uint32(ndr, "level", r->in.level);
15152                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15153                 ndr->depth++;
15154                 if (r->in.buffer) {
15155                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15156                 }
15157                 ndr->depth--;
15158                 ndr_print_uint32(ndr, "offered", r->in.offered);
15159                 ndr->depth--;
15160         }
15161         if (flags & NDR_OUT) {
15162                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
15163                 ndr->depth++;
15164                 ndr_print_ptr(ndr, "info", r->out.info);
15165                 ndr->depth++;
15166                 if (r->out.info) {
15167                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15168                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
15169                 }
15170                 ndr->depth--;
15171                 ndr_print_ptr(ndr, "needed", r->out.needed);
15172                 ndr->depth++;
15173                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15174                 ndr->depth--;
15175                 ndr_print_WERROR(ndr, "result", r->out.result);
15176                 ndr->depth--;
15177         }
15178         ndr->depth--;
15179 }
15180
15181 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
15182 {
15183         if (flags & NDR_IN) {
15184                 if (r->in.handle == NULL) {
15185                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15186                 }
15187                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
15189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
15190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15192                 if (r->in.buffer) {
15193                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15194                 }
15195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15196         }
15197         if (flags & NDR_OUT) {
15198                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15199                 if (r->out.info) {
15200                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15201                 }
15202                 if (r->out.needed == NULL) {
15203                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15204                 }
15205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15206                 if (r->out.count == NULL) {
15207                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15208                 }
15209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15211         }
15212         return NDR_ERR_SUCCESS;
15213 }
15214
15215 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
15216 {
15217         uint32_t _ptr_buffer;
15218         uint32_t _ptr_info;
15219         TALLOC_CTX *_mem_save_handle_0;
15220         TALLOC_CTX *_mem_save_buffer_0;
15221         TALLOC_CTX *_mem_save_info_0;
15222         TALLOC_CTX *_mem_save_needed_0;
15223         TALLOC_CTX *_mem_save_count_0;
15224         if (flags & NDR_IN) {
15225                 ZERO_STRUCT(r->out);
15226
15227                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15228                         NDR_PULL_ALLOC(ndr, r->in.handle);
15229                 }
15230                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15231                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15232                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15233                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
15235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
15236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15238                 if (_ptr_buffer) {
15239                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15240                 } else {
15241                         r->in.buffer = NULL;
15242                 }
15243                 if (r->in.buffer) {
15244                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15245                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15246                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15247                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15248                 }
15249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15250                 NDR_PULL_ALLOC(ndr, r->out.needed);
15251                 ZERO_STRUCTP(r->out.needed);
15252                 NDR_PULL_ALLOC(ndr, r->out.count);
15253                 ZERO_STRUCTP(r->out.count);
15254         }
15255         if (flags & NDR_OUT) {
15256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15257                 if (_ptr_info) {
15258                         NDR_PULL_ALLOC(ndr, r->out.info);
15259                 } else {
15260                         r->out.info = NULL;
15261                 }
15262                 if (r->out.info) {
15263                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15264                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15265                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15267                 }
15268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15269                         NDR_PULL_ALLOC(ndr, r->out.needed);
15270                 }
15271                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15272                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15276                         NDR_PULL_ALLOC(ndr, r->out.count);
15277                 }
15278                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15279                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15283         }
15284         return NDR_ERR_SUCCESS;
15285 }
15286
15287 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
15288 {
15289         uint32_t cntr_info_0;
15290         if (flags & NDR_IN) {
15291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15293         }
15294         if (flags & NDR_OUT) {
15295                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15296                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15297                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15298                 }
15299                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15300                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15301                 }
15302         }
15303         return NDR_ERR_SUCCESS;
15304 }
15305
15306 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
15307 {
15308         uint32_t cntr_info_0;
15309         TALLOC_CTX *_mem_save_info_0;
15310         if (flags & NDR_IN) {
15311                 ZERO_STRUCT(r->out);
15312
15313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15315         }
15316         if (flags & NDR_OUT) {
15317                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15318                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15319                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15320                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15321                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15322                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15323                 }
15324                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15325                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15326                 }
15327                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15328         }
15329         return NDR_ERR_SUCCESS;
15330 }
15331
15332 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
15333 {
15334         uint32_t cntr_info_1;
15335         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
15336         ndr->depth++;
15337         if (flags & NDR_SET_VALUES) {
15338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15339         }
15340         if (flags & NDR_IN) {
15341                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
15342                 ndr->depth++;
15343                 ndr_print_ptr(ndr, "handle", r->in.handle);
15344                 ndr->depth++;
15345                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15346                 ndr->depth--;
15347                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
15348                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
15349                 ndr_print_uint32(ndr, "level", r->in.level);
15350                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15351                 ndr->depth++;
15352                 if (r->in.buffer) {
15353                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15354                 }
15355                 ndr->depth--;
15356                 ndr_print_uint32(ndr, "offered", r->in.offered);
15357                 ndr->depth--;
15358         }
15359         if (flags & NDR_OUT) {
15360                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
15361                 ndr->depth++;
15362                 ndr_print_ptr(ndr, "count", r->out.count);
15363                 ndr->depth++;
15364                 ndr_print_uint32(ndr, "count", *r->out.count);
15365                 ndr->depth--;
15366                 ndr_print_ptr(ndr, "info", r->out.info);
15367                 ndr->depth++;
15368                 if (r->out.info) {
15369                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15370                         ndr->depth++;
15371                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15372                                 char *idx_1=NULL;
15373                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15374                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15375                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
15376                                         free(idx_1);
15377                                 }
15378                         }
15379                         ndr->depth--;
15380                 }
15381                 ndr->depth--;
15382                 ndr_print_ptr(ndr, "needed", r->out.needed);
15383                 ndr->depth++;
15384                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15385                 ndr->depth--;
15386                 ndr_print_WERROR(ndr, "result", r->out.result);
15387                 ndr->depth--;
15388         }
15389         ndr->depth--;
15390 }
15391
15392 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
15393 {
15394         if (flags & NDR_IN) {
15395         }
15396         if (flags & NDR_OUT) {
15397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15398         }
15399         return NDR_ERR_SUCCESS;
15400 }
15401
15402 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
15403 {
15404         if (flags & NDR_IN) {
15405         }
15406         if (flags & NDR_OUT) {
15407                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15408         }
15409         return NDR_ERR_SUCCESS;
15410 }
15411
15412 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
15413 {
15414         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
15415         ndr->depth++;
15416         if (flags & NDR_SET_VALUES) {
15417                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15418         }
15419         if (flags & NDR_IN) {
15420                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
15421                 ndr->depth++;
15422                 ndr->depth--;
15423         }
15424         if (flags & NDR_OUT) {
15425                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
15426                 ndr->depth++;
15427                 ndr_print_WERROR(ndr, "result", r->out.result);
15428                 ndr->depth--;
15429         }
15430         ndr->depth--;
15431 }
15432
15433 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
15434 {
15435         if (flags & NDR_IN) {
15436                 if (r->in.handle == NULL) {
15437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15438                 }
15439                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15440         }
15441         if (flags & NDR_OUT) {
15442                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15443         }
15444         return NDR_ERR_SUCCESS;
15445 }
15446
15447 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
15448 {
15449         TALLOC_CTX *_mem_save_handle_0;
15450         if (flags & NDR_IN) {
15451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15452                         NDR_PULL_ALLOC(ndr, r->in.handle);
15453                 }
15454                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15455                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15456                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15458         }
15459         if (flags & NDR_OUT) {
15460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15461         }
15462         return NDR_ERR_SUCCESS;
15463 }
15464
15465 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
15466 {
15467         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
15468         ndr->depth++;
15469         if (flags & NDR_SET_VALUES) {
15470                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15471         }
15472         if (flags & NDR_IN) {
15473                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
15474                 ndr->depth++;
15475                 ndr_print_ptr(ndr, "handle", r->in.handle);
15476                 ndr->depth++;
15477                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15478                 ndr->depth--;
15479                 ndr->depth--;
15480         }
15481         if (flags & NDR_OUT) {
15482                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
15483                 ndr->depth++;
15484                 ndr_print_WERROR(ndr, "result", r->out.result);
15485                 ndr->depth--;
15486         }
15487         ndr->depth--;
15488 }
15489
15490 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
15491 {
15492         if (flags & NDR_IN) {
15493                 if (r->in.handle == NULL) {
15494                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15495                 }
15496                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15497                 if (r->in.info_ctr == NULL) {
15498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15499                 }
15500                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15501                 if (r->in.devmode_ctr == NULL) {
15502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15503                 }
15504                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15505                 if (r->in.secdesc_ctr == NULL) {
15506                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15507                 }
15508                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15509                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
15510         }
15511         if (flags & NDR_OUT) {
15512                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15513         }
15514         return NDR_ERR_SUCCESS;
15515 }
15516
15517 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
15518 {
15519         TALLOC_CTX *_mem_save_handle_0;
15520         TALLOC_CTX *_mem_save_info_ctr_0;
15521         TALLOC_CTX *_mem_save_devmode_ctr_0;
15522         TALLOC_CTX *_mem_save_secdesc_ctr_0;
15523         if (flags & NDR_IN) {
15524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15525                         NDR_PULL_ALLOC(ndr, r->in.handle);
15526                 }
15527                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15528                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15529                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15532                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15533                 }
15534                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15535                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15536                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15538                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15539                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
15540                 }
15541                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15542                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
15543                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15544                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15545                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15546                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
15547                 }
15548                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15549                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
15550                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15551                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15552                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
15553         }
15554         if (flags & NDR_OUT) {
15555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15556         }
15557         return NDR_ERR_SUCCESS;
15558 }
15559
15560 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
15561 {
15562         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
15563         ndr->depth++;
15564         if (flags & NDR_SET_VALUES) {
15565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15566         }
15567         if (flags & NDR_IN) {
15568                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
15569                 ndr->depth++;
15570                 ndr_print_ptr(ndr, "handle", r->in.handle);
15571                 ndr->depth++;
15572                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15573                 ndr->depth--;
15574                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15575                 ndr->depth++;
15576                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15577                 ndr->depth--;
15578                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
15579                 ndr->depth++;
15580                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
15581                 ndr->depth--;
15582                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15583                 ndr->depth++;
15584                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15585                 ndr->depth--;
15586                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
15587                 ndr->depth--;
15588         }
15589         if (flags & NDR_OUT) {
15590                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
15591                 ndr->depth++;
15592                 ndr_print_WERROR(ndr, "result", r->out.result);
15593                 ndr->depth--;
15594         }
15595         ndr->depth--;
15596 }
15597
15598 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
15599 {
15600         if (flags & NDR_IN) {
15601                 if (r->in.handle == NULL) {
15602                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15603                 }
15604                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15607                 if (r->in.buffer) {
15608                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15609                 }
15610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15611         }
15612         if (flags & NDR_OUT) {
15613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15614                 if (r->out.info) {
15615                         {
15616                                 struct ndr_push *_ndr_info;
15617                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15618                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15619                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15620                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15621                         }
15622                 }
15623                 if (r->out.needed == NULL) {
15624                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15625                 }
15626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15627                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15628         }
15629         return NDR_ERR_SUCCESS;
15630 }
15631
15632 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
15633 {
15634         uint32_t _ptr_buffer;
15635         uint32_t _ptr_info;
15636         TALLOC_CTX *_mem_save_handle_0;
15637         TALLOC_CTX *_mem_save_buffer_0;
15638         TALLOC_CTX *_mem_save_info_0;
15639         TALLOC_CTX *_mem_save_needed_0;
15640         if (flags & NDR_IN) {
15641                 ZERO_STRUCT(r->out);
15642
15643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15644                         NDR_PULL_ALLOC(ndr, r->in.handle);
15645                 }
15646                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15647                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15648                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15652                 if (_ptr_buffer) {
15653                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15654                 } else {
15655                         r->in.buffer = NULL;
15656                 }
15657                 if (r->in.buffer) {
15658                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15659                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15660                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15662                 }
15663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15664                 NDR_PULL_ALLOC(ndr, r->out.needed);
15665                 ZERO_STRUCTP(r->out.needed);
15666         }
15667         if (flags & NDR_OUT) {
15668                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15669                 if (_ptr_info) {
15670                         NDR_PULL_ALLOC(ndr, r->out.info);
15671                 } else {
15672                         r->out.info = NULL;
15673                 }
15674                 if (r->out.info) {
15675                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15676                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15677                         {
15678                                 struct ndr_pull *_ndr_info;
15679                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15680                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15681                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15682                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15683                         }
15684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15685                 }
15686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15687                         NDR_PULL_ALLOC(ndr, r->out.needed);
15688                 }
15689                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15690                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15692                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15693                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15694         }
15695         return NDR_ERR_SUCCESS;
15696 }
15697
15698 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
15699 {
15700         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
15701         ndr->depth++;
15702         if (flags & NDR_SET_VALUES) {
15703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15704         }
15705         if (flags & NDR_IN) {
15706                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
15707                 ndr->depth++;
15708                 ndr_print_ptr(ndr, "handle", r->in.handle);
15709                 ndr->depth++;
15710                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15711                 ndr->depth--;
15712                 ndr_print_uint32(ndr, "level", r->in.level);
15713                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15714                 ndr->depth++;
15715                 if (r->in.buffer) {
15716                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15717                 }
15718                 ndr->depth--;
15719                 ndr_print_uint32(ndr, "offered", r->in.offered);
15720                 ndr->depth--;
15721         }
15722         if (flags & NDR_OUT) {
15723                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
15724                 ndr->depth++;
15725                 ndr_print_ptr(ndr, "info", r->out.info);
15726                 ndr->depth++;
15727                 if (r->out.info) {
15728                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15729                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
15730                 }
15731                 ndr->depth--;
15732                 ndr_print_ptr(ndr, "needed", r->out.needed);
15733                 ndr->depth++;
15734                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15735                 ndr->depth--;
15736                 ndr_print_WERROR(ndr, "result", r->out.result);
15737                 ndr->depth--;
15738         }
15739         ndr->depth--;
15740 }
15741
15742 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
15743 {
15744         if (flags & NDR_IN) {
15745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
15746                 if (r->in.servername) {
15747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15751                 }
15752                 if (r->in.info_ctr == NULL) {
15753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15754                 }
15755                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15756         }
15757         if (flags & NDR_OUT) {
15758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15759         }
15760         return NDR_ERR_SUCCESS;
15761 }
15762
15763 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
15764 {
15765         uint32_t _ptr_servername;
15766         TALLOC_CTX *_mem_save_servername_0;
15767         TALLOC_CTX *_mem_save_info_ctr_0;
15768         if (flags & NDR_IN) {
15769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
15770                 if (_ptr_servername) {
15771                         NDR_PULL_ALLOC(ndr, r->in.servername);
15772                 } else {
15773                         r->in.servername = NULL;
15774                 }
15775                 if (r->in.servername) {
15776                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
15777                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
15778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
15779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
15780                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
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.servername), ndr_get_array_length(ndr, &r->in.servername));
15782                         }
15783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
15784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
15785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
15786                 }
15787                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15788                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15789                 }
15790                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15791                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15792                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15793                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15794         }
15795         if (flags & NDR_OUT) {
15796                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15797         }
15798         return NDR_ERR_SUCCESS;
15799 }
15800
15801 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
15802 {
15803         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
15804         ndr->depth++;
15805         if (flags & NDR_SET_VALUES) {
15806                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15807         }
15808         if (flags & NDR_IN) {
15809                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
15810                 ndr->depth++;
15811                 ndr_print_ptr(ndr, "servername", r->in.servername);
15812                 ndr->depth++;
15813                 if (r->in.servername) {
15814                         ndr_print_string(ndr, "servername", r->in.servername);
15815                 }
15816                 ndr->depth--;
15817                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15818                 ndr->depth++;
15819                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15820                 ndr->depth--;
15821                 ndr->depth--;
15822         }
15823         if (flags & NDR_OUT) {
15824                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
15825                 ndr->depth++;
15826                 ndr_print_WERROR(ndr, "result", r->out.result);
15827                 ndr->depth--;
15828         }
15829         ndr->depth--;
15830 }
15831
15832 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
15833 {
15834         if (flags & NDR_IN) {
15835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15836                 if (r->in.server) {
15837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15838                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15840                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15841                 }
15842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
15843                 if (r->in.environment) {
15844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15848                 }
15849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15851                 if (r->in.buffer) {
15852                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15853                 }
15854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15855         }
15856         if (flags & NDR_OUT) {
15857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15858                 if (r->out.info) {
15859                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15860                 }
15861                 if (r->out.needed == NULL) {
15862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15863                 }
15864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15865                 if (r->out.count == NULL) {
15866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15867                 }
15868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15869                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15870         }
15871         return NDR_ERR_SUCCESS;
15872 }
15873
15874 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
15875 {
15876         uint32_t _ptr_server;
15877         uint32_t _ptr_environment;
15878         uint32_t _ptr_buffer;
15879         uint32_t _ptr_info;
15880         TALLOC_CTX *_mem_save_server_0;
15881         TALLOC_CTX *_mem_save_environment_0;
15882         TALLOC_CTX *_mem_save_buffer_0;
15883         TALLOC_CTX *_mem_save_info_0;
15884         TALLOC_CTX *_mem_save_needed_0;
15885         TALLOC_CTX *_mem_save_count_0;
15886         if (flags & NDR_IN) {
15887                 ZERO_STRUCT(r->out);
15888
15889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15890                 if (_ptr_server) {
15891                         NDR_PULL_ALLOC(ndr, r->in.server);
15892                 } else {
15893                         r->in.server = NULL;
15894                 }
15895                 if (r->in.server) {
15896                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15897                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15898                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15899                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15900                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15901                                 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));
15902                         }
15903                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15904                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15906                 }
15907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
15908                 if (_ptr_environment) {
15909                         NDR_PULL_ALLOC(ndr, r->in.environment);
15910                 } else {
15911                         r->in.environment = NULL;
15912                 }
15913                 if (r->in.environment) {
15914                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
15915                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
15916                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
15917                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
15918                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
15919                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
15920                         }
15921                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
15922                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
15923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
15924                 }
15925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15927                 if (_ptr_buffer) {
15928                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15929                 } else {
15930                         r->in.buffer = NULL;
15931                 }
15932                 if (r->in.buffer) {
15933                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15934                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15935                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15937                 }
15938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15939                 NDR_PULL_ALLOC(ndr, r->out.needed);
15940                 ZERO_STRUCTP(r->out.needed);
15941                 NDR_PULL_ALLOC(ndr, r->out.count);
15942                 ZERO_STRUCTP(r->out.count);
15943         }
15944         if (flags & NDR_OUT) {
15945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15946                 if (_ptr_info) {
15947                         NDR_PULL_ALLOC(ndr, r->out.info);
15948                 } else {
15949                         r->out.info = NULL;
15950                 }
15951                 if (r->out.info) {
15952                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15953                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15954                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15956                 }
15957                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15958                         NDR_PULL_ALLOC(ndr, r->out.needed);
15959                 }
15960                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15961                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15963                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15965                         NDR_PULL_ALLOC(ndr, r->out.count);
15966                 }
15967                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15968                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15971                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15972         }
15973         return NDR_ERR_SUCCESS;
15974 }
15975
15976 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
15977 {
15978         uint32_t cntr_info_0;
15979         if (flags & NDR_IN) {
15980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15982         }
15983         if (flags & NDR_OUT) {
15984                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15985                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15986                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15987                 }
15988                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15989                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15990                 }
15991         }
15992         return NDR_ERR_SUCCESS;
15993 }
15994
15995 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
15996 {
15997         uint32_t cntr_info_0;
15998         TALLOC_CTX *_mem_save_info_0;
15999         if (flags & NDR_IN) {
16000                 ZERO_STRUCT(r->out);
16001
16002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16004         }
16005         if (flags & NDR_OUT) {
16006                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16007                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16008                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16009                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16010                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16011                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16012                 }
16013                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16014                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16015                 }
16016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16017         }
16018         return NDR_ERR_SUCCESS;
16019 }
16020
16021 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
16022 {
16023         uint32_t cntr_info_1;
16024         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
16025         ndr->depth++;
16026         if (flags & NDR_SET_VALUES) {
16027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16028         }
16029         if (flags & NDR_IN) {
16030                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
16031                 ndr->depth++;
16032                 ndr_print_ptr(ndr, "server", r->in.server);
16033                 ndr->depth++;
16034                 if (r->in.server) {
16035                         ndr_print_string(ndr, "server", r->in.server);
16036                 }
16037                 ndr->depth--;
16038                 ndr_print_ptr(ndr, "environment", r->in.environment);
16039                 ndr->depth++;
16040                 if (r->in.environment) {
16041                         ndr_print_string(ndr, "environment", r->in.environment);
16042                 }
16043                 ndr->depth--;
16044                 ndr_print_uint32(ndr, "level", r->in.level);
16045                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16046                 ndr->depth++;
16047                 if (r->in.buffer) {
16048                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16049                 }
16050                 ndr->depth--;
16051                 ndr_print_uint32(ndr, "offered", r->in.offered);
16052                 ndr->depth--;
16053         }
16054         if (flags & NDR_OUT) {
16055                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
16056                 ndr->depth++;
16057                 ndr_print_ptr(ndr, "count", r->out.count);
16058                 ndr->depth++;
16059                 ndr_print_uint32(ndr, "count", *r->out.count);
16060                 ndr->depth--;
16061                 ndr_print_ptr(ndr, "info", r->out.info);
16062                 ndr->depth++;
16063                 if (r->out.info) {
16064                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16065                         ndr->depth++;
16066                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16067                                 char *idx_1=NULL;
16068                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16069                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16070                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
16071                                         free(idx_1);
16072                                 }
16073                         }
16074                         ndr->depth--;
16075                 }
16076                 ndr->depth--;
16077                 ndr_print_ptr(ndr, "needed", r->out.needed);
16078                 ndr->depth++;
16079                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16080                 ndr->depth--;
16081                 ndr_print_WERROR(ndr, "result", r->out.result);
16082                 ndr->depth--;
16083         }
16084         ndr->depth--;
16085 }
16086
16087 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
16088 {
16089         if (flags & NDR_IN) {
16090         }
16091         if (flags & NDR_OUT) {
16092                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16093         }
16094         return NDR_ERR_SUCCESS;
16095 }
16096
16097 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
16098 {
16099         if (flags & NDR_IN) {
16100         }
16101         if (flags & NDR_OUT) {
16102                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16103         }
16104         return NDR_ERR_SUCCESS;
16105 }
16106
16107 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
16108 {
16109         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
16110         ndr->depth++;
16111         if (flags & NDR_SET_VALUES) {
16112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16113         }
16114         if (flags & NDR_IN) {
16115                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
16116                 ndr->depth++;
16117                 ndr->depth--;
16118         }
16119         if (flags & NDR_OUT) {
16120                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
16121                 ndr->depth++;
16122                 ndr_print_WERROR(ndr, "result", r->out.result);
16123                 ndr->depth--;
16124         }
16125         ndr->depth--;
16126 }
16127
16128 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16129 {
16130         if (flags & NDR_IN) {
16131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16132                 if (r->in.server) {
16133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16136                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16137                 }
16138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16139                 if (r->in.environment) {
16140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16143                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16144                 }
16145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16146                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16147                 if (r->in.buffer) {
16148                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16149                 }
16150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16151         }
16152         if (flags & NDR_OUT) {
16153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16154                 if (r->out.info) {
16155                         {
16156                                 struct ndr_push *_ndr_info;
16157                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16158                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16159                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16160                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16161                         }
16162                 }
16163                 if (r->out.needed == NULL) {
16164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16165                 }
16166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16167                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16168         }
16169         return NDR_ERR_SUCCESS;
16170 }
16171
16172 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
16173 {
16174         uint32_t _ptr_server;
16175         uint32_t _ptr_environment;
16176         uint32_t _ptr_buffer;
16177         uint32_t _ptr_info;
16178         TALLOC_CTX *_mem_save_server_0;
16179         TALLOC_CTX *_mem_save_environment_0;
16180         TALLOC_CTX *_mem_save_buffer_0;
16181         TALLOC_CTX *_mem_save_info_0;
16182         TALLOC_CTX *_mem_save_needed_0;
16183         if (flags & NDR_IN) {
16184                 ZERO_STRUCT(r->out);
16185
16186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16187                 if (_ptr_server) {
16188                         NDR_PULL_ALLOC(ndr, r->in.server);
16189                 } else {
16190                         r->in.server = NULL;
16191                 }
16192                 if (r->in.server) {
16193                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16194                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16195                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16196                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16197                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16198                                 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));
16199                         }
16200                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16201                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16203                 }
16204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16205                 if (_ptr_environment) {
16206                         NDR_PULL_ALLOC(ndr, r->in.environment);
16207                 } else {
16208                         r->in.environment = NULL;
16209                 }
16210                 if (r->in.environment) {
16211                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16212                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16214                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16215                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16216                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
16217                         }
16218                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16221                 }
16222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16224                 if (_ptr_buffer) {
16225                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16226                 } else {
16227                         r->in.buffer = NULL;
16228                 }
16229                 if (r->in.buffer) {
16230                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16231                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16232                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16234                 }
16235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16236                 NDR_PULL_ALLOC(ndr, r->out.needed);
16237                 ZERO_STRUCTP(r->out.needed);
16238         }
16239         if (flags & NDR_OUT) {
16240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16241                 if (_ptr_info) {
16242                         NDR_PULL_ALLOC(ndr, r->out.info);
16243                 } else {
16244                         r->out.info = NULL;
16245                 }
16246                 if (r->out.info) {
16247                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16248                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16249                         {
16250                                 struct ndr_pull *_ndr_info;
16251                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16252                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16253                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16254                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16255                         }
16256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16257                 }
16258                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16259                         NDR_PULL_ALLOC(ndr, r->out.needed);
16260                 }
16261                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16262                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16264                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16265                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16266         }
16267         return NDR_ERR_SUCCESS;
16268 }
16269
16270 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16271 {
16272         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
16273         ndr->depth++;
16274         if (flags & NDR_SET_VALUES) {
16275                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16276         }
16277         if (flags & NDR_IN) {
16278                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
16279                 ndr->depth++;
16280                 ndr_print_ptr(ndr, "server", r->in.server);
16281                 ndr->depth++;
16282                 if (r->in.server) {
16283                         ndr_print_string(ndr, "server", r->in.server);
16284                 }
16285                 ndr->depth--;
16286                 ndr_print_ptr(ndr, "environment", r->in.environment);
16287                 ndr->depth++;
16288                 if (r->in.environment) {
16289                         ndr_print_string(ndr, "environment", r->in.environment);
16290                 }
16291                 ndr->depth--;
16292                 ndr_print_uint32(ndr, "level", r->in.level);
16293                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16294                 ndr->depth++;
16295                 if (r->in.buffer) {
16296                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16297                 }
16298                 ndr->depth--;
16299                 ndr_print_uint32(ndr, "offered", r->in.offered);
16300                 ndr->depth--;
16301         }
16302         if (flags & NDR_OUT) {
16303                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
16304                 ndr->depth++;
16305                 ndr_print_ptr(ndr, "info", r->out.info);
16306                 ndr->depth++;
16307                 if (r->out.info) {
16308                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16309                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
16310                 }
16311                 ndr->depth--;
16312                 ndr_print_ptr(ndr, "needed", r->out.needed);
16313                 ndr->depth++;
16314                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16315                 ndr->depth--;
16316                 ndr_print_WERROR(ndr, "result", r->out.result);
16317                 ndr->depth--;
16318         }
16319         ndr->depth--;
16320 }
16321
16322 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
16323 {
16324         if (flags & NDR_IN) {
16325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16326                 if (r->in.server) {
16327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16328                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16329                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16330                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16331                 }
16332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16335                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16339                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16340         }
16341         if (flags & NDR_OUT) {
16342                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16343         }
16344         return NDR_ERR_SUCCESS;
16345 }
16346
16347 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
16348 {
16349         uint32_t _ptr_server;
16350         TALLOC_CTX *_mem_save_server_0;
16351         if (flags & NDR_IN) {
16352                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16353                 if (_ptr_server) {
16354                         NDR_PULL_ALLOC(ndr, r->in.server);
16355                 } else {
16356                         r->in.server = NULL;
16357                 }
16358                 if (r->in.server) {
16359                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16360                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16361                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16362                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16363                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16364                                 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));
16365                         }
16366                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16367                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16368                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16369                 }
16370                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16371                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16372                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16373                         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));
16374                 }
16375                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16376                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16377                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16378                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16379                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16380                         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));
16381                 }
16382                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16383                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16384         }
16385         if (flags & NDR_OUT) {
16386                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16387         }
16388         return NDR_ERR_SUCCESS;
16389 }
16390
16391 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
16392 {
16393         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
16394         ndr->depth++;
16395         if (flags & NDR_SET_VALUES) {
16396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16397         }
16398         if (flags & NDR_IN) {
16399                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
16400                 ndr->depth++;
16401                 ndr_print_ptr(ndr, "server", r->in.server);
16402                 ndr->depth++;
16403                 if (r->in.server) {
16404                         ndr_print_string(ndr, "server", r->in.server);
16405                 }
16406                 ndr->depth--;
16407                 ndr_print_string(ndr, "architecture", r->in.architecture);
16408                 ndr_print_string(ndr, "driver", r->in.driver);
16409                 ndr->depth--;
16410         }
16411         if (flags & NDR_OUT) {
16412                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
16413                 ndr->depth++;
16414                 ndr_print_WERROR(ndr, "result", r->out.result);
16415                 ndr->depth--;
16416         }
16417         ndr->depth--;
16418 }
16419
16420 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
16421 {
16422         if (flags & NDR_IN) {
16423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16424                 if (r->in.server) {
16425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16429                 }
16430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16433                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16437                 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));
16438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16441                 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));
16442         }
16443         if (flags & NDR_OUT) {
16444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16445         }
16446         return NDR_ERR_SUCCESS;
16447 }
16448
16449 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
16450 {
16451         uint32_t _ptr_server;
16452         TALLOC_CTX *_mem_save_server_0;
16453         if (flags & NDR_IN) {
16454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16455                 if (_ptr_server) {
16456                         NDR_PULL_ALLOC(ndr, r->in.server);
16457                 } else {
16458                         r->in.server = NULL;
16459                 }
16460                 if (r->in.server) {
16461                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16462                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16463                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16464                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16465                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16466                                 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));
16467                         }
16468                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16469                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16471                 }
16472                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16473                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16474                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16475                         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));
16476                 }
16477                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16478                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16479                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
16480                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
16481                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
16482                         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));
16483                 }
16484                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
16485                 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));
16486                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
16487                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
16488                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
16489                         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));
16490                 }
16491                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
16492                 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));
16493         }
16494         if (flags & NDR_OUT) {
16495                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16496         }
16497         return NDR_ERR_SUCCESS;
16498 }
16499
16500 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
16501 {
16502         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
16503         ndr->depth++;
16504         if (flags & NDR_SET_VALUES) {
16505                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16506         }
16507         if (flags & NDR_IN) {
16508                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
16509                 ndr->depth++;
16510                 ndr_print_ptr(ndr, "server", r->in.server);
16511                 ndr->depth++;
16512                 if (r->in.server) {
16513                         ndr_print_string(ndr, "server", r->in.server);
16514                 }
16515                 ndr->depth--;
16516                 ndr_print_string(ndr, "architecture", r->in.architecture);
16517                 ndr_print_string(ndr, "path_name", r->in.path_name);
16518                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
16519                 ndr->depth--;
16520         }
16521         if (flags & NDR_OUT) {
16522                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
16523                 ndr->depth++;
16524                 ndr_print_WERROR(ndr, "result", r->out.result);
16525                 ndr->depth--;
16526         }
16527         ndr->depth--;
16528 }
16529
16530 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
16531 {
16532         if (flags & NDR_IN) {
16533                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16534                 if (r->in.servername) {
16535                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16538                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16539                 }
16540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16541                 if (r->in.environment) {
16542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16546                 }
16547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16549                 if (r->in.buffer) {
16550                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16551                 }
16552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16553         }
16554         if (flags & NDR_OUT) {
16555                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16556                 if (r->out.info) {
16557                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16558                 }
16559                 if (r->out.needed == NULL) {
16560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16561                 }
16562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16563                 if (r->out.count == NULL) {
16564                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16565                 }
16566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16567                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16568         }
16569         return NDR_ERR_SUCCESS;
16570 }
16571
16572 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
16573 {
16574         uint32_t _ptr_servername;
16575         uint32_t _ptr_environment;
16576         uint32_t _ptr_buffer;
16577         uint32_t _ptr_info;
16578         TALLOC_CTX *_mem_save_servername_0;
16579         TALLOC_CTX *_mem_save_environment_0;
16580         TALLOC_CTX *_mem_save_buffer_0;
16581         TALLOC_CTX *_mem_save_info_0;
16582         TALLOC_CTX *_mem_save_needed_0;
16583         TALLOC_CTX *_mem_save_count_0;
16584         if (flags & NDR_IN) {
16585                 ZERO_STRUCT(r->out);
16586
16587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16588                 if (_ptr_servername) {
16589                         NDR_PULL_ALLOC(ndr, r->in.servername);
16590                 } else {
16591                         r->in.servername = NULL;
16592                 }
16593                 if (r->in.servername) {
16594                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16595                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16598                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16599                                 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));
16600                         }
16601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16604                 }
16605                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16606                 if (_ptr_environment) {
16607                         NDR_PULL_ALLOC(ndr, r->in.environment);
16608                 } else {
16609                         r->in.environment = NULL;
16610                 }
16611                 if (r->in.environment) {
16612                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16613                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16614                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16615                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16616                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16617                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
16618                         }
16619                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16620                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16621                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16622                 }
16623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16625                 if (_ptr_buffer) {
16626                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16627                 } else {
16628                         r->in.buffer = NULL;
16629                 }
16630                 if (r->in.buffer) {
16631                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16632                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16633                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16635                 }
16636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16637                 NDR_PULL_ALLOC(ndr, r->out.needed);
16638                 ZERO_STRUCTP(r->out.needed);
16639                 NDR_PULL_ALLOC(ndr, r->out.count);
16640                 ZERO_STRUCTP(r->out.count);
16641         }
16642         if (flags & NDR_OUT) {
16643                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16644                 if (_ptr_info) {
16645                         NDR_PULL_ALLOC(ndr, r->out.info);
16646                 } else {
16647                         r->out.info = NULL;
16648                 }
16649                 if (r->out.info) {
16650                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16651                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16652                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16654                 }
16655                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16656                         NDR_PULL_ALLOC(ndr, r->out.needed);
16657                 }
16658                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16659                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16661                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16662                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16663                         NDR_PULL_ALLOC(ndr, r->out.count);
16664                 }
16665                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16666                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16668                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16669                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16670         }
16671         return NDR_ERR_SUCCESS;
16672 }
16673
16674 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
16675 {
16676         uint32_t cntr_info_0;
16677         if (flags & NDR_IN) {
16678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16680         }
16681         if (flags & NDR_OUT) {
16682                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16683                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16684                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16685                 }
16686                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16687                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16688                 }
16689         }
16690         return NDR_ERR_SUCCESS;
16691 }
16692
16693 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
16694 {
16695         uint32_t cntr_info_0;
16696         TALLOC_CTX *_mem_save_info_0;
16697         if (flags & NDR_IN) {
16698                 ZERO_STRUCT(r->out);
16699
16700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16702         }
16703         if (flags & NDR_OUT) {
16704                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16705                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16706                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16707                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16708                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16709                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16710                 }
16711                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16712                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16713                 }
16714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16715         }
16716         return NDR_ERR_SUCCESS;
16717 }
16718
16719 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
16720 {
16721         uint32_t cntr_info_1;
16722         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
16723         ndr->depth++;
16724         if (flags & NDR_SET_VALUES) {
16725                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16726         }
16727         if (flags & NDR_IN) {
16728                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
16729                 ndr->depth++;
16730                 ndr_print_ptr(ndr, "servername", r->in.servername);
16731                 ndr->depth++;
16732                 if (r->in.servername) {
16733                         ndr_print_string(ndr, "servername", r->in.servername);
16734                 }
16735                 ndr->depth--;
16736                 ndr_print_ptr(ndr, "environment", r->in.environment);
16737                 ndr->depth++;
16738                 if (r->in.environment) {
16739                         ndr_print_string(ndr, "environment", r->in.environment);
16740                 }
16741                 ndr->depth--;
16742                 ndr_print_uint32(ndr, "level", r->in.level);
16743                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16744                 ndr->depth++;
16745                 if (r->in.buffer) {
16746                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16747                 }
16748                 ndr->depth--;
16749                 ndr_print_uint32(ndr, "offered", r->in.offered);
16750                 ndr->depth--;
16751         }
16752         if (flags & NDR_OUT) {
16753                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
16754                 ndr->depth++;
16755                 ndr_print_ptr(ndr, "count", r->out.count);
16756                 ndr->depth++;
16757                 ndr_print_uint32(ndr, "count", *r->out.count);
16758                 ndr->depth--;
16759                 ndr_print_ptr(ndr, "info", r->out.info);
16760                 ndr->depth++;
16761                 if (r->out.info) {
16762                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16763                         ndr->depth++;
16764                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16765                                 char *idx_1=NULL;
16766                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16767                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16768                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
16769                                         free(idx_1);
16770                                 }
16771                         }
16772                         ndr->depth--;
16773                 }
16774                 ndr->depth--;
16775                 ndr_print_ptr(ndr, "needed", r->out.needed);
16776                 ndr->depth++;
16777                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16778                 ndr->depth--;
16779                 ndr_print_WERROR(ndr, "result", r->out.result);
16780                 ndr->depth--;
16781         }
16782         ndr->depth--;
16783 }
16784
16785 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16786 {
16787         if (flags & NDR_IN) {
16788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16789                 if (r->in.server) {
16790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16793                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16794                 }
16795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16796                 if (r->in.environment) {
16797                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16800                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16801                 }
16802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16804                 if (r->in.buffer) {
16805                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16806                 }
16807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16808         }
16809         if (flags & NDR_OUT) {
16810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16811                 if (r->out.info) {
16812                         {
16813                                 struct ndr_push *_ndr_info;
16814                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16815                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16816                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16817                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16818                         }
16819                 }
16820                 if (r->out.needed == NULL) {
16821                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16822                 }
16823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16824                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16825         }
16826         return NDR_ERR_SUCCESS;
16827 }
16828
16829 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
16830 {
16831         uint32_t _ptr_server;
16832         uint32_t _ptr_environment;
16833         uint32_t _ptr_buffer;
16834         uint32_t _ptr_info;
16835         TALLOC_CTX *_mem_save_server_0;
16836         TALLOC_CTX *_mem_save_environment_0;
16837         TALLOC_CTX *_mem_save_buffer_0;
16838         TALLOC_CTX *_mem_save_info_0;
16839         TALLOC_CTX *_mem_save_needed_0;
16840         if (flags & NDR_IN) {
16841                 ZERO_STRUCT(r->out);
16842
16843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16844                 if (_ptr_server) {
16845                         NDR_PULL_ALLOC(ndr, r->in.server);
16846                 } else {
16847                         r->in.server = NULL;
16848                 }
16849                 if (r->in.server) {
16850                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16851                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16854                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16855                                 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));
16856                         }
16857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16860                 }
16861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16862                 if (_ptr_environment) {
16863                         NDR_PULL_ALLOC(ndr, r->in.environment);
16864                 } else {
16865                         r->in.environment = NULL;
16866                 }
16867                 if (r->in.environment) {
16868                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16869                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16870                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16871                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16872                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16873                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
16874                         }
16875                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16876                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16878                 }
16879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16881                 if (_ptr_buffer) {
16882                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16883                 } else {
16884                         r->in.buffer = NULL;
16885                 }
16886                 if (r->in.buffer) {
16887                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16888                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16889                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16891                 }
16892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16893                 NDR_PULL_ALLOC(ndr, r->out.needed);
16894                 ZERO_STRUCTP(r->out.needed);
16895         }
16896         if (flags & NDR_OUT) {
16897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16898                 if (_ptr_info) {
16899                         NDR_PULL_ALLOC(ndr, r->out.info);
16900                 } else {
16901                         r->out.info = NULL;
16902                 }
16903                 if (r->out.info) {
16904                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16905                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16906                         {
16907                                 struct ndr_pull *_ndr_info;
16908                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16909                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16910                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16911                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16912                         }
16913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16914                 }
16915                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16916                         NDR_PULL_ALLOC(ndr, r->out.needed);
16917                 }
16918                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16919                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16922                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16923         }
16924         return NDR_ERR_SUCCESS;
16925 }
16926
16927 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16928 {
16929         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
16930         ndr->depth++;
16931         if (flags & NDR_SET_VALUES) {
16932                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16933         }
16934         if (flags & NDR_IN) {
16935                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
16936                 ndr->depth++;
16937                 ndr_print_ptr(ndr, "server", r->in.server);
16938                 ndr->depth++;
16939                 if (r->in.server) {
16940                         ndr_print_string(ndr, "server", r->in.server);
16941                 }
16942                 ndr->depth--;
16943                 ndr_print_ptr(ndr, "environment", r->in.environment);
16944                 ndr->depth++;
16945                 if (r->in.environment) {
16946                         ndr_print_string(ndr, "environment", r->in.environment);
16947                 }
16948                 ndr->depth--;
16949                 ndr_print_uint32(ndr, "level", r->in.level);
16950                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16951                 ndr->depth++;
16952                 if (r->in.buffer) {
16953                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16954                 }
16955                 ndr->depth--;
16956                 ndr_print_uint32(ndr, "offered", r->in.offered);
16957                 ndr->depth--;
16958         }
16959         if (flags & NDR_OUT) {
16960                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
16961                 ndr->depth++;
16962                 ndr_print_ptr(ndr, "info", r->out.info);
16963                 ndr->depth++;
16964                 if (r->out.info) {
16965                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16966                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
16967                 }
16968                 ndr->depth--;
16969                 ndr_print_ptr(ndr, "needed", r->out.needed);
16970                 ndr->depth++;
16971                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16972                 ndr->depth--;
16973                 ndr_print_WERROR(ndr, "result", r->out.result);
16974                 ndr->depth--;
16975         }
16976         ndr->depth--;
16977 }
16978
16979 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
16980 {
16981         if (flags & NDR_IN) {
16982                 if (r->in.handle == NULL) {
16983                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16984                 }
16985                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16987                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
16988                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16989         }
16990         if (flags & NDR_OUT) {
16991                 if (r->out.job_id == NULL) {
16992                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16993                 }
16994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
16995                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16996         }
16997         return NDR_ERR_SUCCESS;
16998 }
16999
17000 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
17001 {
17002         TALLOC_CTX *_mem_save_handle_0;
17003         TALLOC_CTX *_mem_save_job_id_0;
17004         if (flags & NDR_IN) {
17005                 ZERO_STRUCT(r->out);
17006
17007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17008                         NDR_PULL_ALLOC(ndr, r->in.handle);
17009                 }
17010                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17011                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17012                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17015                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17016                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17017                 NDR_PULL_ALLOC(ndr, r->out.job_id);
17018                 ZERO_STRUCTP(r->out.job_id);
17019         }
17020         if (flags & NDR_OUT) {
17021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17022                         NDR_PULL_ALLOC(ndr, r->out.job_id);
17023                 }
17024                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
17025                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
17026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
17027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
17028                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17029         }
17030         return NDR_ERR_SUCCESS;
17031 }
17032
17033 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
17034 {
17035         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
17036         ndr->depth++;
17037         if (flags & NDR_SET_VALUES) {
17038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17039         }
17040         if (flags & NDR_IN) {
17041                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
17042                 ndr->depth++;
17043                 ndr_print_ptr(ndr, "handle", r->in.handle);
17044                 ndr->depth++;
17045                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17046                 ndr->depth--;
17047                 ndr_print_uint32(ndr, "level", r->in.level);
17048                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
17049                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
17050                 ndr->depth--;
17051         }
17052         if (flags & NDR_OUT) {
17053                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
17054                 ndr->depth++;
17055                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
17056                 ndr->depth++;
17057                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
17058                 ndr->depth--;
17059                 ndr_print_WERROR(ndr, "result", r->out.result);
17060                 ndr->depth--;
17061         }
17062         ndr->depth--;
17063 }
17064
17065 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
17066 {
17067         if (flags & NDR_IN) {
17068                 if (r->in.handle == NULL) {
17069                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17070                 }
17071                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17072         }
17073         if (flags & NDR_OUT) {
17074                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17075         }
17076         return NDR_ERR_SUCCESS;
17077 }
17078
17079 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
17080 {
17081         TALLOC_CTX *_mem_save_handle_0;
17082         if (flags & NDR_IN) {
17083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17084                         NDR_PULL_ALLOC(ndr, r->in.handle);
17085                 }
17086                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17087                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17090         }
17091         if (flags & NDR_OUT) {
17092                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17093         }
17094         return NDR_ERR_SUCCESS;
17095 }
17096
17097 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
17098 {
17099         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
17100         ndr->depth++;
17101         if (flags & NDR_SET_VALUES) {
17102                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17103         }
17104         if (flags & NDR_IN) {
17105                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
17106                 ndr->depth++;
17107                 ndr_print_ptr(ndr, "handle", r->in.handle);
17108                 ndr->depth++;
17109                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17110                 ndr->depth--;
17111                 ndr->depth--;
17112         }
17113         if (flags & NDR_OUT) {
17114                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
17115                 ndr->depth++;
17116                 ndr_print_WERROR(ndr, "result", r->out.result);
17117                 ndr->depth--;
17118         }
17119         ndr->depth--;
17120 }
17121
17122 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
17123 {
17124         if (flags & NDR_IN) {
17125                 if (r->in.handle == NULL) {
17126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17127                 }
17128                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17129                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
17131         }
17132         if (flags & NDR_OUT) {
17133                 if (r->out.num_written == NULL) {
17134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17135                 }
17136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
17137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17138         }
17139         return NDR_ERR_SUCCESS;
17140 }
17141
17142 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
17143 {
17144         TALLOC_CTX *_mem_save_handle_0;
17145         TALLOC_CTX *_mem_save_num_written_0;
17146         if (flags & NDR_IN) {
17147                 ZERO_STRUCT(r->out);
17148
17149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17150                         NDR_PULL_ALLOC(ndr, r->in.handle);
17151                 }
17152                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17154                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17156                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
17157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
17158                 NDR_PULL_ALLOC(ndr, r->out.num_written);
17159                 ZERO_STRUCTP(r->out.num_written);
17160         }
17161         if (flags & NDR_OUT) {
17162                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17163                         NDR_PULL_ALLOC(ndr, r->out.num_written);
17164                 }
17165                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
17166                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
17167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
17168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
17169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17170         }
17171         return NDR_ERR_SUCCESS;
17172 }
17173
17174 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
17175 {
17176         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
17177         ndr->depth++;
17178         if (flags & NDR_SET_VALUES) {
17179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17180         }
17181         if (flags & NDR_IN) {
17182                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
17183                 ndr->depth++;
17184                 ndr_print_ptr(ndr, "handle", r->in.handle);
17185                 ndr->depth++;
17186                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17187                 ndr->depth--;
17188                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
17189                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
17190                 ndr->depth--;
17191         }
17192         if (flags & NDR_OUT) {
17193                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
17194                 ndr->depth++;
17195                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
17196                 ndr->depth++;
17197                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
17198                 ndr->depth--;
17199                 ndr_print_WERROR(ndr, "result", r->out.result);
17200                 ndr->depth--;
17201         }
17202         ndr->depth--;
17203 }
17204
17205 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
17206 {
17207         if (flags & NDR_IN) {
17208                 if (r->in.handle == NULL) {
17209                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17210                 }
17211                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17212         }
17213         if (flags & NDR_OUT) {
17214                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17215         }
17216         return NDR_ERR_SUCCESS;
17217 }
17218
17219 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
17220 {
17221         TALLOC_CTX *_mem_save_handle_0;
17222         if (flags & NDR_IN) {
17223                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17224                         NDR_PULL_ALLOC(ndr, r->in.handle);
17225                 }
17226                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17227                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17228                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17229                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17230         }
17231         if (flags & NDR_OUT) {
17232                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17233         }
17234         return NDR_ERR_SUCCESS;
17235 }
17236
17237 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
17238 {
17239         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
17240         ndr->depth++;
17241         if (flags & NDR_SET_VALUES) {
17242                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17243         }
17244         if (flags & NDR_IN) {
17245                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
17246                 ndr->depth++;
17247                 ndr_print_ptr(ndr, "handle", r->in.handle);
17248                 ndr->depth++;
17249                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17250                 ndr->depth--;
17251                 ndr->depth--;
17252         }
17253         if (flags & NDR_OUT) {
17254                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
17255                 ndr->depth++;
17256                 ndr_print_WERROR(ndr, "result", r->out.result);
17257                 ndr->depth--;
17258         }
17259         ndr->depth--;
17260 }
17261
17262 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
17263 {
17264         if (flags & NDR_IN) {
17265                 if (r->in.handle == NULL) {
17266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17267                 }
17268                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17269         }
17270         if (flags & NDR_OUT) {
17271                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17272         }
17273         return NDR_ERR_SUCCESS;
17274 }
17275
17276 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
17277 {
17278         TALLOC_CTX *_mem_save_handle_0;
17279         if (flags & NDR_IN) {
17280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17281                         NDR_PULL_ALLOC(ndr, r->in.handle);
17282                 }
17283                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17287         }
17288         if (flags & NDR_OUT) {
17289                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17290         }
17291         return NDR_ERR_SUCCESS;
17292 }
17293
17294 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
17295 {
17296         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
17297         ndr->depth++;
17298         if (flags & NDR_SET_VALUES) {
17299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17300         }
17301         if (flags & NDR_IN) {
17302                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
17303                 ndr->depth++;
17304                 ndr_print_ptr(ndr, "handle", r->in.handle);
17305                 ndr->depth++;
17306                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17307                 ndr->depth--;
17308                 ndr->depth--;
17309         }
17310         if (flags & NDR_OUT) {
17311                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
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_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *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_uint32(ndr, NDR_SCALARS, r->in.data_size));
17327         }
17328         if (flags & NDR_OUT) {
17329                 if (r->out.data == NULL) {
17330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17331                 }
17332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17333                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
17334                 if (r->out._data_size == NULL) {
17335                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17336                 }
17337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
17338                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17339         }
17340         return NDR_ERR_SUCCESS;
17341 }
17342
17343 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
17344 {
17345         TALLOC_CTX *_mem_save_handle_0;
17346         TALLOC_CTX *_mem_save__data_size_0;
17347         if (flags & NDR_IN) {
17348                 ZERO_STRUCT(r->out);
17349
17350                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17351                         NDR_PULL_ALLOC(ndr, r->in.handle);
17352                 }
17353                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17354                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17355                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17356                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
17358                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
17359                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
17360                 NDR_PULL_ALLOC(ndr, r->out._data_size);
17361                 ZERO_STRUCTP(r->out._data_size);
17362         }
17363         if (flags & NDR_OUT) {
17364                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
17365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17366                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
17367                 }
17368                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
17369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17370                         NDR_PULL_ALLOC(ndr, r->out._data_size);
17371                 }
17372                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
17373                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
17374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
17375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
17376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17377                 if (r->out.data) {
17378                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
17379                 }
17380         }
17381         return NDR_ERR_SUCCESS;
17382 }
17383
17384 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
17385 {
17386         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
17387         ndr->depth++;
17388         if (flags & NDR_SET_VALUES) {
17389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17390         }
17391         if (flags & NDR_IN) {
17392                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
17393                 ndr->depth++;
17394                 ndr_print_ptr(ndr, "handle", r->in.handle);
17395                 ndr->depth++;
17396                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17397                 ndr->depth--;
17398                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
17399                 ndr->depth--;
17400         }
17401         if (flags & NDR_OUT) {
17402                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
17403                 ndr->depth++;
17404                 ndr_print_ptr(ndr, "data", r->out.data);
17405                 ndr->depth++;
17406                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
17407                 ndr->depth--;
17408                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
17409                 ndr->depth++;
17410                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
17411                 ndr->depth--;
17412                 ndr_print_WERROR(ndr, "result", r->out.result);
17413                 ndr->depth--;
17414         }
17415         ndr->depth--;
17416 }
17417
17418 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
17419 {
17420         if (flags & NDR_IN) {
17421                 if (r->in.handle == NULL) {
17422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17423                 }
17424                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17425         }
17426         if (flags & NDR_OUT) {
17427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17428         }
17429         return NDR_ERR_SUCCESS;
17430 }
17431
17432 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
17433 {
17434         TALLOC_CTX *_mem_save_handle_0;
17435         if (flags & NDR_IN) {
17436                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17437                         NDR_PULL_ALLOC(ndr, r->in.handle);
17438                 }
17439                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17440                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17441                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17442                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17443         }
17444         if (flags & NDR_OUT) {
17445                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17446         }
17447         return NDR_ERR_SUCCESS;
17448 }
17449
17450 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
17451 {
17452         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
17453         ndr->depth++;
17454         if (flags & NDR_SET_VALUES) {
17455                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17456         }
17457         if (flags & NDR_IN) {
17458                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
17459                 ndr->depth++;
17460                 ndr_print_ptr(ndr, "handle", r->in.handle);
17461                 ndr->depth++;
17462                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17463                 ndr->depth--;
17464                 ndr->depth--;
17465         }
17466         if (flags & NDR_OUT) {
17467                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
17468                 ndr->depth++;
17469                 ndr_print_WERROR(ndr, "result", r->out.result);
17470                 ndr->depth--;
17471         }
17472         ndr->depth--;
17473 }
17474
17475 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
17476 {
17477         if (flags & NDR_IN) {
17478                 if (r->in.handle == NULL) {
17479                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17480                 }
17481                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17483                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17484                 if (r->in.buffer) {
17485                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17486                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
17487                 }
17488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17489         }
17490         if (flags & NDR_OUT) {
17491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
17492                 if (r->out.buffer) {
17493                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17494                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
17495                 }
17496                 if (r->out.needed == NULL) {
17497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17498                 }
17499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17500                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17501         }
17502         return NDR_ERR_SUCCESS;
17503 }
17504
17505 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
17506 {
17507         uint32_t _ptr_buffer;
17508         TALLOC_CTX *_mem_save_handle_0;
17509         TALLOC_CTX *_mem_save_buffer_0;
17510         TALLOC_CTX *_mem_save_needed_0;
17511         if (flags & NDR_IN) {
17512                 ZERO_STRUCT(r->out);
17513
17514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17515                         NDR_PULL_ALLOC(ndr, r->in.handle);
17516                 }
17517                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17518                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17519                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17523                 if (_ptr_buffer) {
17524                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17525                 } else {
17526                         r->in.buffer = NULL;
17527                 }
17528                 if (r->in.buffer) {
17529                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17530                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
17532                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
17533                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
17534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17535                 }
17536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17537                 NDR_PULL_ALLOC(ndr, r->out.needed);
17538                 ZERO_STRUCTP(r->out.needed);
17539                 if (r->in.buffer) {
17540                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
17541                 }
17542         }
17543         if (flags & NDR_OUT) {
17544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17545                 if (_ptr_buffer) {
17546                         NDR_PULL_ALLOC(ndr, r->out.buffer);
17547                 } else {
17548                         r->out.buffer = NULL;
17549                 }
17550                 if (r->out.buffer) {
17551                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17552                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
17553                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
17554                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
17555                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
17556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17557                 }
17558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17559                         NDR_PULL_ALLOC(ndr, r->out.needed);
17560                 }
17561                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17562                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17565                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17566                 if (r->out.buffer) {
17567                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
17568                 }
17569         }
17570         return NDR_ERR_SUCCESS;
17571 }
17572
17573 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
17574 {
17575         ndr_print_struct(ndr, name, "spoolss_AddJob");
17576         ndr->depth++;
17577         if (flags & NDR_SET_VALUES) {
17578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17579         }
17580         if (flags & NDR_IN) {
17581                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
17582                 ndr->depth++;
17583                 ndr_print_ptr(ndr, "handle", r->in.handle);
17584                 ndr->depth++;
17585                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17586                 ndr->depth--;
17587                 ndr_print_uint32(ndr, "level", r->in.level);
17588                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17589                 ndr->depth++;
17590                 if (r->in.buffer) {
17591                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
17592                 }
17593                 ndr->depth--;
17594                 ndr_print_uint32(ndr, "offered", r->in.offered);
17595                 ndr->depth--;
17596         }
17597         if (flags & NDR_OUT) {
17598                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
17599                 ndr->depth++;
17600                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
17601                 ndr->depth++;
17602                 if (r->out.buffer) {
17603                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
17604                 }
17605                 ndr->depth--;
17606                 ndr_print_ptr(ndr, "needed", r->out.needed);
17607                 ndr->depth++;
17608                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17609                 ndr->depth--;
17610                 ndr_print_WERROR(ndr, "result", r->out.result);
17611                 ndr->depth--;
17612         }
17613         ndr->depth--;
17614 }
17615
17616 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
17617 {
17618         if (flags & NDR_IN) {
17619                 if (r->in.handle == NULL) {
17620                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17621                 }
17622                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
17624         }
17625         if (flags & NDR_OUT) {
17626                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17627         }
17628         return NDR_ERR_SUCCESS;
17629 }
17630
17631 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
17632 {
17633         TALLOC_CTX *_mem_save_handle_0;
17634         if (flags & NDR_IN) {
17635                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17636                         NDR_PULL_ALLOC(ndr, r->in.handle);
17637                 }
17638                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17639                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17640                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17641                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
17643         }
17644         if (flags & NDR_OUT) {
17645                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17646         }
17647         return NDR_ERR_SUCCESS;
17648 }
17649
17650 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
17651 {
17652         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
17653         ndr->depth++;
17654         if (flags & NDR_SET_VALUES) {
17655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17656         }
17657         if (flags & NDR_IN) {
17658                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
17659                 ndr->depth++;
17660                 ndr_print_ptr(ndr, "handle", r->in.handle);
17661                 ndr->depth++;
17662                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17663                 ndr->depth--;
17664                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
17665                 ndr->depth--;
17666         }
17667         if (flags & NDR_OUT) {
17668                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
17669                 ndr->depth++;
17670                 ndr_print_WERROR(ndr, "result", r->out.result);
17671                 ndr->depth--;
17672         }
17673         ndr->depth--;
17674 }
17675
17676 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
17677 {
17678         if (flags & NDR_IN) {
17679                 if (r->in.handle == NULL) {
17680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17681                 }
17682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17686                 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));
17687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17688         }
17689         if (flags & NDR_OUT) {
17690                 if (r->out.type == NULL) {
17691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17692                 }
17693                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
17694                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
17695                 if (r->out.needed == NULL) {
17696                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17697                 }
17698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17700         }
17701         return NDR_ERR_SUCCESS;
17702 }
17703
17704 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
17705 {
17706         TALLOC_CTX *_mem_save_handle_0;
17707         TALLOC_CTX *_mem_save_type_0;
17708         TALLOC_CTX *_mem_save_needed_0;
17709         if (flags & NDR_IN) {
17710                 ZERO_STRUCT(r->out);
17711
17712                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17713                         NDR_PULL_ALLOC(ndr, r->in.handle);
17714                 }
17715                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17716                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17717                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17718                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17719                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17720                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17721                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17722                         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));
17723                 }
17724                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17725                 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));
17726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17727                 NDR_PULL_ALLOC(ndr, r->out.type);
17728                 ZERO_STRUCTP(r->out.type);
17729                 NDR_PULL_ALLOC(ndr, r->out.needed);
17730                 ZERO_STRUCTP(r->out.needed);
17731         }
17732         if (flags & NDR_OUT) {
17733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17734                         NDR_PULL_ALLOC(ndr, r->out.type);
17735                 }
17736                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
17737                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
17738                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
17739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
17740                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
17741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17742                         NDR_PULL_ALLOC(ndr, r->out.needed);
17743                 }
17744                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17745                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17749         }
17750         return NDR_ERR_SUCCESS;
17751 }
17752
17753 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
17754 {
17755         if (flags & NDR_IN) {
17756                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17757         }
17758         if (flags & NDR_OUT) {
17759                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17760                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17761         }
17762         return NDR_ERR_SUCCESS;
17763 }
17764
17765 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
17766 {
17767         if (flags & NDR_IN) {
17768                 ZERO_STRUCT(r->out);
17769
17770                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17771         }
17772         if (flags & NDR_OUT) {
17773                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
17774                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17775         }
17776         return NDR_ERR_SUCCESS;
17777 }
17778
17779 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
17780 {
17781         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
17782         ndr->depth++;
17783         if (flags & NDR_SET_VALUES) {
17784                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17785         }
17786         if (flags & NDR_IN) {
17787                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
17788                 ndr->depth++;
17789                 ndr_print_ptr(ndr, "handle", r->in.handle);
17790                 ndr->depth++;
17791                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17792                 ndr->depth--;
17793                 ndr_print_string(ndr, "value_name", r->in.value_name);
17794                 ndr_print_uint32(ndr, "offered", r->in.offered);
17795                 ndr->depth--;
17796         }
17797         if (flags & NDR_OUT) {
17798                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
17799                 ndr->depth++;
17800                 ndr_print_ptr(ndr, "type", r->out.type);
17801                 ndr->depth++;
17802                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
17803                 ndr->depth--;
17804                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
17805                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
17806                 ndr_print_ptr(ndr, "needed", r->out.needed);
17807                 ndr->depth++;
17808                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17809                 ndr->depth--;
17810                 ndr_print_WERROR(ndr, "result", r->out.result);
17811                 ndr->depth--;
17812         }
17813         ndr->depth--;
17814 }
17815
17816 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
17817 {
17818         if (flags & NDR_IN) {
17819                 if (r->in.handle == NULL) {
17820                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17821                 }
17822                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17826                 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));
17827                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17828                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
17830         }
17831         if (flags & NDR_OUT) {
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_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
17838 {
17839         if (flags & NDR_IN) {
17840                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17841         }
17842         if (flags & NDR_OUT) {
17843                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17844                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17845         }
17846         return NDR_ERR_SUCCESS;
17847 }
17848
17849 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
17850 {
17851         TALLOC_CTX *_mem_save_handle_0;
17852         if (flags & NDR_IN) {
17853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17854                         NDR_PULL_ALLOC(ndr, r->in.handle);
17855                 }
17856                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17857                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17858                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17860                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17861                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17862                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17863                         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));
17864                 }
17865                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17866                 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));
17867                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17868                 {
17869                         struct ndr_pull *_ndr_data;
17870                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
17871                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
17872                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
17873                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
17874                 }
17875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
17876         }
17877         if (flags & NDR_OUT) {
17878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17879         }
17880         return NDR_ERR_SUCCESS;
17881 }
17882
17883 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
17884 {
17885         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
17886         ndr->depth++;
17887         if (flags & NDR_SET_VALUES) {
17888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17889         }
17890         if (flags & NDR_IN) {
17891                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
17892                 ndr->depth++;
17893                 ndr_print_ptr(ndr, "handle", r->in.handle);
17894                 ndr->depth++;
17895                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17896                 ndr->depth--;
17897                 ndr_print_string(ndr, "value_name", r->in.value_name);
17898                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
17899                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
17900                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
17901                 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);
17902                 ndr->depth--;
17903         }
17904         if (flags & NDR_OUT) {
17905                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
17906                 ndr->depth++;
17907                 ndr_print_WERROR(ndr, "result", r->out.result);
17908                 ndr->depth--;
17909         }
17910         ndr->depth--;
17911 }
17912
17913 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
17914 {
17915         if (flags & NDR_IN) {
17916         }
17917         if (flags & NDR_OUT) {
17918                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17919         }
17920         return NDR_ERR_SUCCESS;
17921 }
17922
17923 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
17924 {
17925         if (flags & NDR_IN) {
17926         }
17927         if (flags & NDR_OUT) {
17928                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17929         }
17930         return NDR_ERR_SUCCESS;
17931 }
17932
17933 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
17934 {
17935         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
17936         ndr->depth++;
17937         if (flags & NDR_SET_VALUES) {
17938                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17939         }
17940         if (flags & NDR_IN) {
17941                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
17942                 ndr->depth++;
17943                 ndr->depth--;
17944         }
17945         if (flags & NDR_OUT) {
17946                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
17947                 ndr->depth++;
17948                 ndr_print_WERROR(ndr, "result", r->out.result);
17949                 ndr->depth--;
17950         }
17951         ndr->depth--;
17952 }
17953
17954 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
17955 {
17956         if (flags & NDR_IN) {
17957                 if (r->in.handle == NULL) {
17958                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17959                 }
17960                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17961         }
17962         if (flags & NDR_OUT) {
17963                 if (r->out.handle == NULL) {
17964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17965                 }
17966                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17967                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17968         }
17969         return NDR_ERR_SUCCESS;
17970 }
17971
17972 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
17973 {
17974         TALLOC_CTX *_mem_save_handle_0;
17975         if (flags & NDR_IN) {
17976                 ZERO_STRUCT(r->out);
17977
17978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17979                         NDR_PULL_ALLOC(ndr, r->in.handle);
17980                 }
17981                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17982                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17983                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17985                 NDR_PULL_ALLOC(ndr, r->out.handle);
17986                 *r->out.handle = *r->in.handle;
17987         }
17988         if (flags & NDR_OUT) {
17989                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17990                         NDR_PULL_ALLOC(ndr, r->out.handle);
17991                 }
17992                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17993                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
17994                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17995                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17996                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17997         }
17998         return NDR_ERR_SUCCESS;
17999 }
18000
18001 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
18002 {
18003         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
18004         ndr->depth++;
18005         if (flags & NDR_SET_VALUES) {
18006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18007         }
18008         if (flags & NDR_IN) {
18009                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
18010                 ndr->depth++;
18011                 ndr_print_ptr(ndr, "handle", r->in.handle);
18012                 ndr->depth++;
18013                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18014                 ndr->depth--;
18015                 ndr->depth--;
18016         }
18017         if (flags & NDR_OUT) {
18018                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
18019                 ndr->depth++;
18020                 ndr_print_ptr(ndr, "handle", r->out.handle);
18021                 ndr->depth++;
18022                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18023                 ndr->depth--;
18024                 ndr_print_WERROR(ndr, "result", r->out.result);
18025                 ndr->depth--;
18026         }
18027         ndr->depth--;
18028 }
18029
18030 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
18031 {
18032         if (flags & NDR_IN) {
18033                 if (r->in.handle == NULL) {
18034                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18035                 }
18036                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18038                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18039                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18040         }
18041         if (flags & NDR_OUT) {
18042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18043         }
18044         return NDR_ERR_SUCCESS;
18045 }
18046
18047 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
18048 {
18049         TALLOC_CTX *_mem_save_handle_0;
18050         if (flags & NDR_IN) {
18051                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18052                         NDR_PULL_ALLOC(ndr, r->in.handle);
18053                 }
18054                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18055                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18056                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18059                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18060                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18061         }
18062         if (flags & NDR_OUT) {
18063                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18064         }
18065         return NDR_ERR_SUCCESS;
18066 }
18067
18068 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
18069 {
18070         ndr_print_struct(ndr, name, "spoolss_AddForm");
18071         ndr->depth++;
18072         if (flags & NDR_SET_VALUES) {
18073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18074         }
18075         if (flags & NDR_IN) {
18076                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
18077                 ndr->depth++;
18078                 ndr_print_ptr(ndr, "handle", r->in.handle);
18079                 ndr->depth++;
18080                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18081                 ndr->depth--;
18082                 ndr_print_uint32(ndr, "level", r->in.level);
18083                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18084                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18085                 ndr->depth--;
18086         }
18087         if (flags & NDR_OUT) {
18088                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
18089                 ndr->depth++;
18090                 ndr_print_WERROR(ndr, "result", r->out.result);
18091                 ndr->depth--;
18092         }
18093         ndr->depth--;
18094 }
18095
18096 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
18097 {
18098         if (flags & NDR_IN) {
18099                 if (r->in.handle == NULL) {
18100                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18101                 }
18102                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18106                 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));
18107         }
18108         if (flags & NDR_OUT) {
18109                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18110         }
18111         return NDR_ERR_SUCCESS;
18112 }
18113
18114 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
18115 {
18116         TALLOC_CTX *_mem_save_handle_0;
18117         if (flags & NDR_IN) {
18118                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18119                         NDR_PULL_ALLOC(ndr, r->in.handle);
18120                 }
18121                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18122                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18123                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18125                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18126                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18127                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18128                         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));
18129                 }
18130                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18131                 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));
18132         }
18133         if (flags & NDR_OUT) {
18134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18135         }
18136         return NDR_ERR_SUCCESS;
18137 }
18138
18139 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
18140 {
18141         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
18142         ndr->depth++;
18143         if (flags & NDR_SET_VALUES) {
18144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18145         }
18146         if (flags & NDR_IN) {
18147                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
18148                 ndr->depth++;
18149                 ndr_print_ptr(ndr, "handle", r->in.handle);
18150                 ndr->depth++;
18151                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18152                 ndr->depth--;
18153                 ndr_print_string(ndr, "form_name", r->in.form_name);
18154                 ndr->depth--;
18155         }
18156         if (flags & NDR_OUT) {
18157                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
18158                 ndr->depth++;
18159                 ndr_print_WERROR(ndr, "result", r->out.result);
18160                 ndr->depth--;
18161         }
18162         ndr->depth--;
18163 }
18164
18165 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
18166 {
18167         if (flags & NDR_IN) {
18168                 if (r->in.handle == NULL) {
18169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18170                 }
18171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18175                 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));
18176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18178                 if (r->in.buffer) {
18179                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18180                 }
18181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18182         }
18183         if (flags & NDR_OUT) {
18184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18185                 if (r->out.info) {
18186                         {
18187                                 struct ndr_push *_ndr_info;
18188                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18189                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18190                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18191                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18192                         }
18193                 }
18194                 if (r->out.needed == NULL) {
18195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18196                 }
18197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18198                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18199         }
18200         return NDR_ERR_SUCCESS;
18201 }
18202
18203 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
18204 {
18205         uint32_t _ptr_buffer;
18206         uint32_t _ptr_info;
18207         TALLOC_CTX *_mem_save_handle_0;
18208         TALLOC_CTX *_mem_save_buffer_0;
18209         TALLOC_CTX *_mem_save_info_0;
18210         TALLOC_CTX *_mem_save_needed_0;
18211         if (flags & NDR_IN) {
18212                 ZERO_STRUCT(r->out);
18213
18214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18215                         NDR_PULL_ALLOC(ndr, r->in.handle);
18216                 }
18217                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18218                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18221                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18222                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18223                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18224                         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));
18225                 }
18226                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18227                 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));
18228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18230                 if (_ptr_buffer) {
18231                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18232                 } else {
18233                         r->in.buffer = NULL;
18234                 }
18235                 if (r->in.buffer) {
18236                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18238                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18240                 }
18241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18242                 NDR_PULL_ALLOC(ndr, r->out.needed);
18243                 ZERO_STRUCTP(r->out.needed);
18244         }
18245         if (flags & NDR_OUT) {
18246                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18247                 if (_ptr_info) {
18248                         NDR_PULL_ALLOC(ndr, r->out.info);
18249                 } else {
18250                         r->out.info = NULL;
18251                 }
18252                 if (r->out.info) {
18253                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18254                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18255                         {
18256                                 struct ndr_pull *_ndr_info;
18257                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18258                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18259                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18260                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18261                         }
18262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18263                 }
18264                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18265                         NDR_PULL_ALLOC(ndr, r->out.needed);
18266                 }
18267                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18268                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18271                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18272         }
18273         return NDR_ERR_SUCCESS;
18274 }
18275
18276 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
18277 {
18278         ndr_print_struct(ndr, name, "spoolss_GetForm");
18279         ndr->depth++;
18280         if (flags & NDR_SET_VALUES) {
18281                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18282         }
18283         if (flags & NDR_IN) {
18284                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
18285                 ndr->depth++;
18286                 ndr_print_ptr(ndr, "handle", r->in.handle);
18287                 ndr->depth++;
18288                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18289                 ndr->depth--;
18290                 ndr_print_string(ndr, "form_name", r->in.form_name);
18291                 ndr_print_uint32(ndr, "level", r->in.level);
18292                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18293                 ndr->depth++;
18294                 if (r->in.buffer) {
18295                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18296                 }
18297                 ndr->depth--;
18298                 ndr_print_uint32(ndr, "offered", r->in.offered);
18299                 ndr->depth--;
18300         }
18301         if (flags & NDR_OUT) {
18302                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
18303                 ndr->depth++;
18304                 ndr_print_ptr(ndr, "info", r->out.info);
18305                 ndr->depth++;
18306                 if (r->out.info) {
18307                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18308                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
18309                 }
18310                 ndr->depth--;
18311                 ndr_print_ptr(ndr, "needed", r->out.needed);
18312                 ndr->depth++;
18313                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18314                 ndr->depth--;
18315                 ndr_print_WERROR(ndr, "result", r->out.result);
18316                 ndr->depth--;
18317         }
18318         ndr->depth--;
18319 }
18320
18321 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
18322 {
18323         if (flags & NDR_IN) {
18324                 if (r->in.handle == NULL) {
18325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18326                 }
18327                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18331                 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));
18332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18333                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18334                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18335         }
18336         if (flags & NDR_OUT) {
18337                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18338         }
18339         return NDR_ERR_SUCCESS;
18340 }
18341
18342 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
18343 {
18344         TALLOC_CTX *_mem_save_handle_0;
18345         if (flags & NDR_IN) {
18346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18347                         NDR_PULL_ALLOC(ndr, r->in.handle);
18348                 }
18349                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18350                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18351                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18353                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18354                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18355                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18356                         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));
18357                 }
18358                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18359                 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));
18360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18361                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18362                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18363         }
18364         if (flags & NDR_OUT) {
18365                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18366         }
18367         return NDR_ERR_SUCCESS;
18368 }
18369
18370 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
18371 {
18372         ndr_print_struct(ndr, name, "spoolss_SetForm");
18373         ndr->depth++;
18374         if (flags & NDR_SET_VALUES) {
18375                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18376         }
18377         if (flags & NDR_IN) {
18378                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
18379                 ndr->depth++;
18380                 ndr_print_ptr(ndr, "handle", r->in.handle);
18381                 ndr->depth++;
18382                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18383                 ndr->depth--;
18384                 ndr_print_string(ndr, "form_name", r->in.form_name);
18385                 ndr_print_uint32(ndr, "level", r->in.level);
18386                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18387                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18388                 ndr->depth--;
18389         }
18390         if (flags & NDR_OUT) {
18391                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
18392                 ndr->depth++;
18393                 ndr_print_WERROR(ndr, "result", r->out.result);
18394                 ndr->depth--;
18395         }
18396         ndr->depth--;
18397 }
18398
18399 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
18400 {
18401         if (flags & NDR_IN) {
18402                 if (r->in.handle == NULL) {
18403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18404                 }
18405                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18408                 if (r->in.buffer) {
18409                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18410                 }
18411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18412         }
18413         if (flags & NDR_OUT) {
18414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18415                 if (r->out.info) {
18416                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18417                 }
18418                 if (r->out.needed == NULL) {
18419                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18420                 }
18421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18422                 if (r->out.count == NULL) {
18423                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18424                 }
18425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18426                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18427         }
18428         return NDR_ERR_SUCCESS;
18429 }
18430
18431 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
18432 {
18433         uint32_t _ptr_buffer;
18434         uint32_t _ptr_info;
18435         TALLOC_CTX *_mem_save_handle_0;
18436         TALLOC_CTX *_mem_save_buffer_0;
18437         TALLOC_CTX *_mem_save_info_0;
18438         TALLOC_CTX *_mem_save_needed_0;
18439         TALLOC_CTX *_mem_save_count_0;
18440         if (flags & NDR_IN) {
18441                 ZERO_STRUCT(r->out);
18442
18443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18444                         NDR_PULL_ALLOC(ndr, r->in.handle);
18445                 }
18446                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18447                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18448                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18452                 if (_ptr_buffer) {
18453                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18454                 } else {
18455                         r->in.buffer = NULL;
18456                 }
18457                 if (r->in.buffer) {
18458                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18459                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18460                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18461                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18462                 }
18463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18464                 NDR_PULL_ALLOC(ndr, r->out.needed);
18465                 ZERO_STRUCTP(r->out.needed);
18466                 NDR_PULL_ALLOC(ndr, r->out.count);
18467                 ZERO_STRUCTP(r->out.count);
18468         }
18469         if (flags & NDR_OUT) {
18470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18471                 if (_ptr_info) {
18472                         NDR_PULL_ALLOC(ndr, r->out.info);
18473                 } else {
18474                         r->out.info = NULL;
18475                 }
18476                 if (r->out.info) {
18477                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18478                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18479                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18481                 }
18482                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18483                         NDR_PULL_ALLOC(ndr, r->out.needed);
18484                 }
18485                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18486                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18490                         NDR_PULL_ALLOC(ndr, r->out.count);
18491                 }
18492                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18493                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18495                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18496                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18497         }
18498         return NDR_ERR_SUCCESS;
18499 }
18500
18501 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
18502 {
18503         uint32_t cntr_info_0;
18504         if (flags & NDR_IN) {
18505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18507         }
18508         if (flags & NDR_OUT) {
18509                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18510                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18511                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18512                 }
18513                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18514                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18515                 }
18516         }
18517         return NDR_ERR_SUCCESS;
18518 }
18519
18520 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
18521 {
18522         uint32_t cntr_info_0;
18523         TALLOC_CTX *_mem_save_info_0;
18524         if (flags & NDR_IN) {
18525                 ZERO_STRUCT(r->out);
18526
18527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18529         }
18530         if (flags & NDR_OUT) {
18531                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18532                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18533                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18534                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18535                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18536                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18537                 }
18538                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18539                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18540                 }
18541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18542         }
18543         return NDR_ERR_SUCCESS;
18544 }
18545
18546 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
18547 {
18548         uint32_t cntr_info_1;
18549         ndr_print_struct(ndr, name, "spoolss_EnumForms");
18550         ndr->depth++;
18551         if (flags & NDR_SET_VALUES) {
18552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18553         }
18554         if (flags & NDR_IN) {
18555                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
18556                 ndr->depth++;
18557                 ndr_print_ptr(ndr, "handle", r->in.handle);
18558                 ndr->depth++;
18559                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18560                 ndr->depth--;
18561                 ndr_print_uint32(ndr, "level", r->in.level);
18562                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18563                 ndr->depth++;
18564                 if (r->in.buffer) {
18565                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18566                 }
18567                 ndr->depth--;
18568                 ndr_print_uint32(ndr, "offered", r->in.offered);
18569                 ndr->depth--;
18570         }
18571         if (flags & NDR_OUT) {
18572                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
18573                 ndr->depth++;
18574                 ndr_print_ptr(ndr, "count", r->out.count);
18575                 ndr->depth++;
18576                 ndr_print_uint32(ndr, "count", *r->out.count);
18577                 ndr->depth--;
18578                 ndr_print_ptr(ndr, "info", r->out.info);
18579                 ndr->depth++;
18580                 if (r->out.info) {
18581                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18582                         ndr->depth++;
18583                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18584                                 char *idx_1=NULL;
18585                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18586                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18587                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
18588                                         free(idx_1);
18589                                 }
18590                         }
18591                         ndr->depth--;
18592                 }
18593                 ndr->depth--;
18594                 ndr_print_ptr(ndr, "needed", r->out.needed);
18595                 ndr->depth++;
18596                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18597                 ndr->depth--;
18598                 ndr_print_WERROR(ndr, "result", r->out.result);
18599                 ndr->depth--;
18600         }
18601         ndr->depth--;
18602 }
18603
18604 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
18605 {
18606         if (flags & NDR_IN) {
18607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18608                 if (r->in.servername) {
18609                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18610                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18611                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18612                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18613                 }
18614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18616                 if (r->in.buffer) {
18617                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18618                 }
18619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18620         }
18621         if (flags & NDR_OUT) {
18622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18623                 if (r->out.info) {
18624                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18625                 }
18626                 if (r->out.needed == NULL) {
18627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18628                 }
18629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18630                 if (r->out.count == NULL) {
18631                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18632                 }
18633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18635         }
18636         return NDR_ERR_SUCCESS;
18637 }
18638
18639 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
18640 {
18641         uint32_t _ptr_servername;
18642         uint32_t _ptr_buffer;
18643         uint32_t _ptr_info;
18644         TALLOC_CTX *_mem_save_servername_0;
18645         TALLOC_CTX *_mem_save_buffer_0;
18646         TALLOC_CTX *_mem_save_info_0;
18647         TALLOC_CTX *_mem_save_needed_0;
18648         TALLOC_CTX *_mem_save_count_0;
18649         if (flags & NDR_IN) {
18650                 ZERO_STRUCT(r->out);
18651
18652                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18653                 if (_ptr_servername) {
18654                         NDR_PULL_ALLOC(ndr, r->in.servername);
18655                 } else {
18656                         r->in.servername = NULL;
18657                 }
18658                 if (r->in.servername) {
18659                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18660                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18661                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18662                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18663                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18664                                 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));
18665                         }
18666                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18667                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18669                 }
18670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18671                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18672                 if (_ptr_buffer) {
18673                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18674                 } else {
18675                         r->in.buffer = NULL;
18676                 }
18677                 if (r->in.buffer) {
18678                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18679                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18680                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18682                 }
18683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18684                 NDR_PULL_ALLOC(ndr, r->out.needed);
18685                 ZERO_STRUCTP(r->out.needed);
18686                 NDR_PULL_ALLOC(ndr, r->out.count);
18687                 ZERO_STRUCTP(r->out.count);
18688         }
18689         if (flags & NDR_OUT) {
18690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18691                 if (_ptr_info) {
18692                         NDR_PULL_ALLOC(ndr, r->out.info);
18693                 } else {
18694                         r->out.info = NULL;
18695                 }
18696                 if (r->out.info) {
18697                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18698                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18699                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18700                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18701                 }
18702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18703                         NDR_PULL_ALLOC(ndr, r->out.needed);
18704                 }
18705                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18706                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18709                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18710                         NDR_PULL_ALLOC(ndr, r->out.count);
18711                 }
18712                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18713                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18715                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18716                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18717         }
18718         return NDR_ERR_SUCCESS;
18719 }
18720
18721 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
18722 {
18723         uint32_t cntr_info_0;
18724         if (flags & NDR_IN) {
18725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18727         }
18728         if (flags & NDR_OUT) {
18729                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18730                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18731                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18732                 }
18733                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18734                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18735                 }
18736         }
18737         return NDR_ERR_SUCCESS;
18738 }
18739
18740 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
18741 {
18742         uint32_t cntr_info_0;
18743         TALLOC_CTX *_mem_save_info_0;
18744         if (flags & NDR_IN) {
18745                 ZERO_STRUCT(r->out);
18746
18747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18749         }
18750         if (flags & NDR_OUT) {
18751                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18752                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18753                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18754                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18755                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18756                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18757                 }
18758                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18759                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18760                 }
18761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18762         }
18763         return NDR_ERR_SUCCESS;
18764 }
18765
18766 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
18767 {
18768         uint32_t cntr_info_1;
18769         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
18770         ndr->depth++;
18771         if (flags & NDR_SET_VALUES) {
18772                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18773         }
18774         if (flags & NDR_IN) {
18775                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
18776                 ndr->depth++;
18777                 ndr_print_ptr(ndr, "servername", r->in.servername);
18778                 ndr->depth++;
18779                 if (r->in.servername) {
18780                         ndr_print_string(ndr, "servername", r->in.servername);
18781                 }
18782                 ndr->depth--;
18783                 ndr_print_uint32(ndr, "level", r->in.level);
18784                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18785                 ndr->depth++;
18786                 if (r->in.buffer) {
18787                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18788                 }
18789                 ndr->depth--;
18790                 ndr_print_uint32(ndr, "offered", r->in.offered);
18791                 ndr->depth--;
18792         }
18793         if (flags & NDR_OUT) {
18794                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
18795                 ndr->depth++;
18796                 ndr_print_ptr(ndr, "count", r->out.count);
18797                 ndr->depth++;
18798                 ndr_print_uint32(ndr, "count", *r->out.count);
18799                 ndr->depth--;
18800                 ndr_print_ptr(ndr, "info", r->out.info);
18801                 ndr->depth++;
18802                 if (r->out.info) {
18803                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18804                         ndr->depth++;
18805                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18806                                 char *idx_1=NULL;
18807                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18808                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18809                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
18810                                         free(idx_1);
18811                                 }
18812                         }
18813                         ndr->depth--;
18814                 }
18815                 ndr->depth--;
18816                 ndr_print_ptr(ndr, "needed", r->out.needed);
18817                 ndr->depth++;
18818                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18819                 ndr->depth--;
18820                 ndr_print_WERROR(ndr, "result", r->out.result);
18821                 ndr->depth--;
18822         }
18823         ndr->depth--;
18824 }
18825
18826 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
18827 {
18828         if (flags & NDR_IN) {
18829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18830                 if (r->in.servername) {
18831                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18832                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18834                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18835                 }
18836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18838                 if (r->in.buffer) {
18839                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18840                 }
18841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18842         }
18843         if (flags & NDR_OUT) {
18844                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18845                 if (r->out.info) {
18846                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18847                 }
18848                 if (r->out.needed == NULL) {
18849                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18850                 }
18851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18852                 if (r->out.count == NULL) {
18853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18854                 }
18855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18856                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18857         }
18858         return NDR_ERR_SUCCESS;
18859 }
18860
18861 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
18862 {
18863         uint32_t _ptr_servername;
18864         uint32_t _ptr_buffer;
18865         uint32_t _ptr_info;
18866         TALLOC_CTX *_mem_save_servername_0;
18867         TALLOC_CTX *_mem_save_buffer_0;
18868         TALLOC_CTX *_mem_save_info_0;
18869         TALLOC_CTX *_mem_save_needed_0;
18870         TALLOC_CTX *_mem_save_count_0;
18871         if (flags & NDR_IN) {
18872                 ZERO_STRUCT(r->out);
18873
18874                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18875                 if (_ptr_servername) {
18876                         NDR_PULL_ALLOC(ndr, r->in.servername);
18877                 } else {
18878                         r->in.servername = NULL;
18879                 }
18880                 if (r->in.servername) {
18881                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18882                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18884                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18885                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18886                                 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));
18887                         }
18888                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18889                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18891                 }
18892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18893                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18894                 if (_ptr_buffer) {
18895                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18896                 } else {
18897                         r->in.buffer = NULL;
18898                 }
18899                 if (r->in.buffer) {
18900                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18901                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18902                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18903                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18904                 }
18905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18906                 NDR_PULL_ALLOC(ndr, r->out.needed);
18907                 ZERO_STRUCTP(r->out.needed);
18908                 NDR_PULL_ALLOC(ndr, r->out.count);
18909                 ZERO_STRUCTP(r->out.count);
18910         }
18911         if (flags & NDR_OUT) {
18912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18913                 if (_ptr_info) {
18914                         NDR_PULL_ALLOC(ndr, r->out.info);
18915                 } else {
18916                         r->out.info = NULL;
18917                 }
18918                 if (r->out.info) {
18919                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18920                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18921                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18923                 }
18924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18925                         NDR_PULL_ALLOC(ndr, r->out.needed);
18926                 }
18927                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18928                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18932                         NDR_PULL_ALLOC(ndr, r->out.count);
18933                 }
18934                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18935                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18938                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18939         }
18940         return NDR_ERR_SUCCESS;
18941 }
18942
18943 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
18944 {
18945         uint32_t cntr_info_0;
18946         if (flags & NDR_IN) {
18947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18949         }
18950         if (flags & NDR_OUT) {
18951                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18952                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18953                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18954                 }
18955                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18956                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18957                 }
18958         }
18959         return NDR_ERR_SUCCESS;
18960 }
18961
18962 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
18963 {
18964         uint32_t cntr_info_0;
18965         TALLOC_CTX *_mem_save_info_0;
18966         if (flags & NDR_IN) {
18967                 ZERO_STRUCT(r->out);
18968
18969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18971         }
18972         if (flags & NDR_OUT) {
18973                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18974                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18975                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18976                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18977                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18978                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18979                 }
18980                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18981                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18982                 }
18983                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18984         }
18985         return NDR_ERR_SUCCESS;
18986 }
18987
18988 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
18989 {
18990         uint32_t cntr_info_1;
18991         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
18992         ndr->depth++;
18993         if (flags & NDR_SET_VALUES) {
18994                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18995         }
18996         if (flags & NDR_IN) {
18997                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
18998                 ndr->depth++;
18999                 ndr_print_ptr(ndr, "servername", r->in.servername);
19000                 ndr->depth++;
19001                 if (r->in.servername) {
19002                         ndr_print_string(ndr, "servername", r->in.servername);
19003                 }
19004                 ndr->depth--;
19005                 ndr_print_uint32(ndr, "level", r->in.level);
19006                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19007                 ndr->depth++;
19008                 if (r->in.buffer) {
19009                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19010                 }
19011                 ndr->depth--;
19012                 ndr_print_uint32(ndr, "offered", r->in.offered);
19013                 ndr->depth--;
19014         }
19015         if (flags & NDR_OUT) {
19016                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
19017                 ndr->depth++;
19018                 ndr_print_ptr(ndr, "count", r->out.count);
19019                 ndr->depth++;
19020                 ndr_print_uint32(ndr, "count", *r->out.count);
19021                 ndr->depth--;
19022                 ndr_print_ptr(ndr, "info", r->out.info);
19023                 ndr->depth++;
19024                 if (r->out.info) {
19025                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19026                         ndr->depth++;
19027                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19028                                 char *idx_1=NULL;
19029                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19030                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
19031                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
19032                                         free(idx_1);
19033                                 }
19034                         }
19035                         ndr->depth--;
19036                 }
19037                 ndr->depth--;
19038                 ndr_print_ptr(ndr, "needed", r->out.needed);
19039                 ndr->depth++;
19040                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19041                 ndr->depth--;
19042                 ndr_print_WERROR(ndr, "result", r->out.result);
19043                 ndr->depth--;
19044         }
19045         ndr->depth--;
19046 }
19047
19048 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
19049 {
19050         if (flags & NDR_IN) {
19051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
19052                 if (r->in.server_name) {
19053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19056                         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));
19057                 }
19058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
19059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19062                 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));
19063         }
19064         if (flags & NDR_OUT) {
19065                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19066         }
19067         return NDR_ERR_SUCCESS;
19068 }
19069
19070 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
19071 {
19072         uint32_t _ptr_server_name;
19073         TALLOC_CTX *_mem_save_server_name_0;
19074         if (flags & NDR_IN) {
19075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
19076                 if (_ptr_server_name) {
19077                         NDR_PULL_ALLOC(ndr, r->in.server_name);
19078                 } else {
19079                         r->in.server_name = NULL;
19080                 }
19081                 if (r->in.server_name) {
19082                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19083                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
19084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
19085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
19086                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
19087                                 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));
19088                         }
19089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
19090                         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));
19091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
19092                 }
19093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
19094                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
19095                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
19096                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
19097                         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));
19098                 }
19099                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
19100                 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));
19101         }
19102         if (flags & NDR_OUT) {
19103                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19104         }
19105         return NDR_ERR_SUCCESS;
19106 }
19107
19108 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
19109 {
19110         ndr_print_struct(ndr, name, "spoolss_AddPort");
19111         ndr->depth++;
19112         if (flags & NDR_SET_VALUES) {
19113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19114         }
19115         if (flags & NDR_IN) {
19116                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
19117                 ndr->depth++;
19118                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
19119                 ndr->depth++;
19120                 if (r->in.server_name) {
19121                         ndr_print_string(ndr, "server_name", r->in.server_name);
19122                 }
19123                 ndr->depth--;
19124                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
19125                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
19126                 ndr->depth--;
19127         }
19128         if (flags & NDR_OUT) {
19129                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
19130                 ndr->depth++;
19131                 ndr_print_WERROR(ndr, "result", r->out.result);
19132                 ndr->depth--;
19133         }
19134         ndr->depth--;
19135 }
19136
19137 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
19138 {
19139         if (flags & NDR_IN) {
19140         }
19141         if (flags & NDR_OUT) {
19142                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19143         }
19144         return NDR_ERR_SUCCESS;
19145 }
19146
19147 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
19148 {
19149         if (flags & NDR_IN) {
19150         }
19151         if (flags & NDR_OUT) {
19152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19153         }
19154         return NDR_ERR_SUCCESS;
19155 }
19156
19157 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
19158 {
19159         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
19160         ndr->depth++;
19161         if (flags & NDR_SET_VALUES) {
19162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19163         }
19164         if (flags & NDR_IN) {
19165                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
19166                 ndr->depth++;
19167                 ndr->depth--;
19168         }
19169         if (flags & NDR_OUT) {
19170                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
19171                 ndr->depth++;
19172                 ndr_print_WERROR(ndr, "result", r->out.result);
19173                 ndr->depth--;
19174         }
19175         ndr->depth--;
19176 }
19177
19178 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
19179 {
19180         if (flags & NDR_IN) {
19181         }
19182         if (flags & NDR_OUT) {
19183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19184         }
19185         return NDR_ERR_SUCCESS;
19186 }
19187
19188 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
19189 {
19190         if (flags & NDR_IN) {
19191         }
19192         if (flags & NDR_OUT) {
19193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19194         }
19195         return NDR_ERR_SUCCESS;
19196 }
19197
19198 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
19199 {
19200         ndr_print_struct(ndr, name, "spoolss_DeletePort");
19201         ndr->depth++;
19202         if (flags & NDR_SET_VALUES) {
19203                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19204         }
19205         if (flags & NDR_IN) {
19206                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
19207                 ndr->depth++;
19208                 ndr->depth--;
19209         }
19210         if (flags & NDR_OUT) {
19211                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
19212                 ndr->depth++;
19213                 ndr_print_WERROR(ndr, "result", r->out.result);
19214                 ndr->depth--;
19215         }
19216         ndr->depth--;
19217 }
19218
19219 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
19220 {
19221         if (flags & NDR_IN) {
19222         }
19223         if (flags & NDR_OUT) {
19224                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19225         }
19226         return NDR_ERR_SUCCESS;
19227 }
19228
19229 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
19230 {
19231         if (flags & NDR_IN) {
19232         }
19233         if (flags & NDR_OUT) {
19234                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19235         }
19236         return NDR_ERR_SUCCESS;
19237 }
19238
19239 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
19240 {
19241         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
19242         ndr->depth++;
19243         if (flags & NDR_SET_VALUES) {
19244                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19245         }
19246         if (flags & NDR_IN) {
19247                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
19248                 ndr->depth++;
19249                 ndr->depth--;
19250         }
19251         if (flags & NDR_OUT) {
19252                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
19253                 ndr->depth++;
19254                 ndr_print_WERROR(ndr, "result", r->out.result);
19255                 ndr->depth--;
19256         }
19257         ndr->depth--;
19258 }
19259
19260 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19261 {
19262         if (flags & NDR_IN) {
19263         }
19264         if (flags & NDR_OUT) {
19265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19266         }
19267         return NDR_ERR_SUCCESS;
19268 }
19269
19270 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
19271 {
19272         if (flags & NDR_IN) {
19273         }
19274         if (flags & NDR_OUT) {
19275                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19276         }
19277         return NDR_ERR_SUCCESS;
19278 }
19279
19280 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19281 {
19282         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
19283         ndr->depth++;
19284         if (flags & NDR_SET_VALUES) {
19285                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19286         }
19287         if (flags & NDR_IN) {
19288                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
19289                 ndr->depth++;
19290                 ndr->depth--;
19291         }
19292         if (flags & NDR_OUT) {
19293                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
19294                 ndr->depth++;
19295                 ndr_print_WERROR(ndr, "result", r->out.result);
19296                 ndr->depth--;
19297         }
19298         ndr->depth--;
19299 }
19300
19301 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
19302 {
19303         if (flags & NDR_IN) {
19304         }
19305         if (flags & NDR_OUT) {
19306                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19307         }
19308         return NDR_ERR_SUCCESS;
19309 }
19310
19311 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
19312 {
19313         if (flags & NDR_IN) {
19314         }
19315         if (flags & NDR_OUT) {
19316                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19317         }
19318         return NDR_ERR_SUCCESS;
19319 }
19320
19321 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
19322 {
19323         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
19324         ndr->depth++;
19325         if (flags & NDR_SET_VALUES) {
19326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19327         }
19328         if (flags & NDR_IN) {
19329                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
19330                 ndr->depth++;
19331                 ndr->depth--;
19332         }
19333         if (flags & NDR_OUT) {
19334                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
19335                 ndr->depth++;
19336                 ndr_print_WERROR(ndr, "result", r->out.result);
19337                 ndr->depth--;
19338         }
19339         ndr->depth--;
19340 }
19341
19342 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
19343 {
19344         if (flags & NDR_IN) {
19345         }
19346         if (flags & NDR_OUT) {
19347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19348         }
19349         return NDR_ERR_SUCCESS;
19350 }
19351
19352 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
19353 {
19354         if (flags & NDR_IN) {
19355         }
19356         if (flags & NDR_OUT) {
19357                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19358         }
19359         return NDR_ERR_SUCCESS;
19360 }
19361
19362 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
19363 {
19364         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
19365         ndr->depth++;
19366         if (flags & NDR_SET_VALUES) {
19367                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19368         }
19369         if (flags & NDR_IN) {
19370                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
19371                 ndr->depth++;
19372                 ndr->depth--;
19373         }
19374         if (flags & NDR_OUT) {
19375                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
19376                 ndr->depth++;
19377                 ndr_print_WERROR(ndr, "result", r->out.result);
19378                 ndr->depth--;
19379         }
19380         ndr->depth--;
19381 }
19382
19383 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
19384 {
19385         if (flags & NDR_IN) {
19386         }
19387         if (flags & NDR_OUT) {
19388                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19389         }
19390         return NDR_ERR_SUCCESS;
19391 }
19392
19393 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
19394 {
19395         if (flags & NDR_IN) {
19396         }
19397         if (flags & NDR_OUT) {
19398                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19399         }
19400         return NDR_ERR_SUCCESS;
19401 }
19402
19403 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
19404 {
19405         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
19406         ndr->depth++;
19407         if (flags & NDR_SET_VALUES) {
19408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19409         }
19410         if (flags & NDR_IN) {
19411                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
19412                 ndr->depth++;
19413                 ndr->depth--;
19414         }
19415         if (flags & NDR_OUT) {
19416                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
19417                 ndr->depth++;
19418                 ndr_print_WERROR(ndr, "result", r->out.result);
19419                 ndr->depth--;
19420         }
19421         ndr->depth--;
19422 }
19423
19424 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
19425 {
19426         if (flags & NDR_IN) {
19427         }
19428         if (flags & NDR_OUT) {
19429                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19430         }
19431         return NDR_ERR_SUCCESS;
19432 }
19433
19434 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
19435 {
19436         if (flags & NDR_IN) {
19437         }
19438         if (flags & NDR_OUT) {
19439                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19440         }
19441         return NDR_ERR_SUCCESS;
19442 }
19443
19444 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
19445 {
19446         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
19447         ndr->depth++;
19448         if (flags & NDR_SET_VALUES) {
19449                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19450         }
19451         if (flags & NDR_IN) {
19452                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
19453                 ndr->depth++;
19454                 ndr->depth--;
19455         }
19456         if (flags & NDR_OUT) {
19457                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
19458                 ndr->depth++;
19459                 ndr_print_WERROR(ndr, "result", r->out.result);
19460                 ndr->depth--;
19461         }
19462         ndr->depth--;
19463 }
19464
19465 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
19466 {
19467         if (flags & NDR_IN) {
19468         }
19469         if (flags & NDR_OUT) {
19470                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19471         }
19472         return NDR_ERR_SUCCESS;
19473 }
19474
19475 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
19476 {
19477         if (flags & NDR_IN) {
19478         }
19479         if (flags & NDR_OUT) {
19480                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19481         }
19482         return NDR_ERR_SUCCESS;
19483 }
19484
19485 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
19486 {
19487         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
19488         ndr->depth++;
19489         if (flags & NDR_SET_VALUES) {
19490                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19491         }
19492         if (flags & NDR_IN) {
19493                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
19494                 ndr->depth++;
19495                 ndr->depth--;
19496         }
19497         if (flags & NDR_OUT) {
19498                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
19499                 ndr->depth++;
19500                 ndr_print_WERROR(ndr, "result", r->out.result);
19501                 ndr->depth--;
19502         }
19503         ndr->depth--;
19504 }
19505
19506 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
19507 {
19508         if (flags & NDR_IN) {
19509         }
19510         if (flags & NDR_OUT) {
19511                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19512         }
19513         return NDR_ERR_SUCCESS;
19514 }
19515
19516 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
19517 {
19518         if (flags & NDR_IN) {
19519         }
19520         if (flags & NDR_OUT) {
19521                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19522         }
19523         return NDR_ERR_SUCCESS;
19524 }
19525
19526 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
19527 {
19528         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
19529         ndr->depth++;
19530         if (flags & NDR_SET_VALUES) {
19531                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19532         }
19533         if (flags & NDR_IN) {
19534                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
19535                 ndr->depth++;
19536                 ndr->depth--;
19537         }
19538         if (flags & NDR_OUT) {
19539                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
19540                 ndr->depth++;
19541                 ndr_print_WERROR(ndr, "result", r->out.result);
19542                 ndr->depth--;
19543         }
19544         ndr->depth--;
19545 }
19546
19547 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
19548 {
19549         if (flags & NDR_IN) {
19550         }
19551         if (flags & NDR_OUT) {
19552                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19553         }
19554         return NDR_ERR_SUCCESS;
19555 }
19556
19557 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
19558 {
19559         if (flags & NDR_IN) {
19560         }
19561         if (flags & NDR_OUT) {
19562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19563         }
19564         return NDR_ERR_SUCCESS;
19565 }
19566
19567 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
19568 {
19569         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
19570         ndr->depth++;
19571         if (flags & NDR_SET_VALUES) {
19572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19573         }
19574         if (flags & NDR_IN) {
19575                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
19576                 ndr->depth++;
19577                 ndr->depth--;
19578         }
19579         if (flags & NDR_OUT) {
19580                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
19581                 ndr->depth++;
19582                 ndr_print_WERROR(ndr, "result", r->out.result);
19583                 ndr->depth--;
19584         }
19585         ndr->depth--;
19586 }
19587
19588 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
19589 {
19590         if (flags & NDR_IN) {
19591         }
19592         if (flags & NDR_OUT) {
19593                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19594         }
19595         return NDR_ERR_SUCCESS;
19596 }
19597
19598 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
19599 {
19600         if (flags & NDR_IN) {
19601         }
19602         if (flags & NDR_OUT) {
19603                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19604         }
19605         return NDR_ERR_SUCCESS;
19606 }
19607
19608 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
19609 {
19610         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
19611         ndr->depth++;
19612         if (flags & NDR_SET_VALUES) {
19613                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19614         }
19615         if (flags & NDR_IN) {
19616                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
19617                 ndr->depth++;
19618                 ndr->depth--;
19619         }
19620         if (flags & NDR_OUT) {
19621                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
19622                 ndr->depth++;
19623                 ndr_print_WERROR(ndr, "result", r->out.result);
19624                 ndr->depth--;
19625         }
19626         ndr->depth--;
19627 }
19628
19629 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
19630 {
19631         if (flags & NDR_IN) {
19632         }
19633         if (flags & NDR_OUT) {
19634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19635         }
19636         return NDR_ERR_SUCCESS;
19637 }
19638
19639 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
19640 {
19641         if (flags & NDR_IN) {
19642         }
19643         if (flags & NDR_OUT) {
19644                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19645         }
19646         return NDR_ERR_SUCCESS;
19647 }
19648
19649 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
19650 {
19651         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
19652         ndr->depth++;
19653         if (flags & NDR_SET_VALUES) {
19654                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19655         }
19656         if (flags & NDR_IN) {
19657                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
19658                 ndr->depth++;
19659                 ndr->depth--;
19660         }
19661         if (flags & NDR_OUT) {
19662                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
19663                 ndr->depth++;
19664                 ndr_print_WERROR(ndr, "result", r->out.result);
19665                 ndr->depth--;
19666         }
19667         ndr->depth--;
19668 }
19669
19670 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19671 {
19672         if (flags & NDR_IN) {
19673         }
19674         if (flags & NDR_OUT) {
19675                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19676         }
19677         return NDR_ERR_SUCCESS;
19678 }
19679
19680 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
19681 {
19682         if (flags & NDR_IN) {
19683         }
19684         if (flags & NDR_OUT) {
19685                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19686         }
19687         return NDR_ERR_SUCCESS;
19688 }
19689
19690 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19691 {
19692         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
19693         ndr->depth++;
19694         if (flags & NDR_SET_VALUES) {
19695                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19696         }
19697         if (flags & NDR_IN) {
19698                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
19699                 ndr->depth++;
19700                 ndr->depth--;
19701         }
19702         if (flags & NDR_OUT) {
19703                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
19704                 ndr->depth++;
19705                 ndr_print_WERROR(ndr, "result", r->out.result);
19706                 ndr->depth--;
19707         }
19708         ndr->depth--;
19709 }
19710
19711 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
19712 {
19713         if (flags & NDR_IN) {
19714                 if (r->in.handle == NULL) {
19715                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19716                 }
19717                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
19719                 if (r->in.data_type) {
19720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19723                         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));
19724                 }
19725                 if (r->in.devmode_ctr == NULL) {
19726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19727                 }
19728                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19729         }
19730         if (flags & NDR_OUT) {
19731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19732         }
19733         return NDR_ERR_SUCCESS;
19734 }
19735
19736 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
19737 {
19738         uint32_t _ptr_data_type;
19739         TALLOC_CTX *_mem_save_handle_0;
19740         TALLOC_CTX *_mem_save_data_type_0;
19741         TALLOC_CTX *_mem_save_devmode_ctr_0;
19742         if (flags & NDR_IN) {
19743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19744                         NDR_PULL_ALLOC(ndr, r->in.handle);
19745                 }
19746                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19747                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19748                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
19751                 if (_ptr_data_type) {
19752                         NDR_PULL_ALLOC(ndr, r->in.data_type);
19753                 } else {
19754                         r->in.data_type = NULL;
19755                 }
19756                 if (r->in.data_type) {
19757                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
19758                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
19759                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
19760                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
19761                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
19762                                 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));
19763                         }
19764                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
19765                         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));
19766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
19767                 }
19768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19769                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19770                 }
19771                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19772                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19773                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19774                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19775         }
19776         if (flags & NDR_OUT) {
19777                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19778         }
19779         return NDR_ERR_SUCCESS;
19780 }
19781
19782 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
19783 {
19784         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
19785         ndr->depth++;
19786         if (flags & NDR_SET_VALUES) {
19787                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19788         }
19789         if (flags & NDR_IN) {
19790                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
19791                 ndr->depth++;
19792                 ndr_print_ptr(ndr, "handle", r->in.handle);
19793                 ndr->depth++;
19794                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19795                 ndr->depth--;
19796                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
19797                 ndr->depth++;
19798                 if (r->in.data_type) {
19799                         ndr_print_string(ndr, "data_type", r->in.data_type);
19800                 }
19801                 ndr->depth--;
19802                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19803                 ndr->depth++;
19804                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19805                 ndr->depth--;
19806                 ndr->depth--;
19807         }
19808         if (flags & NDR_OUT) {
19809                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
19810                 ndr->depth++;
19811                 ndr_print_WERROR(ndr, "result", r->out.result);
19812                 ndr->depth--;
19813         }
19814         ndr->depth--;
19815 }
19816
19817 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
19818 {
19819         if (flags & NDR_IN) {
19820                 if (r->in.handle == NULL) {
19821                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19822                 }
19823                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19824                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
19825                 if (r->in.architecture) {
19826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19830                 }
19831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19833                 if (r->in.buffer) {
19834                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19835                 }
19836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
19838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
19839         }
19840         if (flags & NDR_OUT) {
19841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19842                 if (r->out.info) {
19843                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19844                 }
19845                 if (r->out.needed == NULL) {
19846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19847                 }
19848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19849                 if (r->out.server_major_version == NULL) {
19850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19851                 }
19852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
19853                 if (r->out.server_minor_version == NULL) {
19854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19855                 }
19856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
19857                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19858         }
19859         return NDR_ERR_SUCCESS;
19860 }
19861
19862 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
19863 {
19864         uint32_t _ptr_architecture;
19865         uint32_t _ptr_buffer;
19866         uint32_t _ptr_info;
19867         TALLOC_CTX *_mem_save_handle_0;
19868         TALLOC_CTX *_mem_save_architecture_0;
19869         TALLOC_CTX *_mem_save_buffer_0;
19870         TALLOC_CTX *_mem_save_info_0;
19871         TALLOC_CTX *_mem_save_needed_0;
19872         TALLOC_CTX *_mem_save_server_major_version_0;
19873         TALLOC_CTX *_mem_save_server_minor_version_0;
19874         if (flags & NDR_IN) {
19875                 ZERO_STRUCT(r->out);
19876
19877                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19878                         NDR_PULL_ALLOC(ndr, r->in.handle);
19879                 }
19880                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19881                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19882                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
19885                 if (_ptr_architecture) {
19886                         NDR_PULL_ALLOC(ndr, r->in.architecture);
19887                 } else {
19888                         r->in.architecture = NULL;
19889                 }
19890                 if (r->in.architecture) {
19891                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
19892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
19893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
19894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
19895                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
19896                                 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));
19897                         }
19898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
19899                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
19900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
19901                 }
19902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19904                 if (_ptr_buffer) {
19905                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19906                 } else {
19907                         r->in.buffer = NULL;
19908                 }
19909                 if (r->in.buffer) {
19910                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19911                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19912                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19914                 }
19915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
19917                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
19918                 NDR_PULL_ALLOC(ndr, r->out.needed);
19919                 ZERO_STRUCTP(r->out.needed);
19920                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19921                 ZERO_STRUCTP(r->out.server_major_version);
19922                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19923                 ZERO_STRUCTP(r->out.server_minor_version);
19924         }
19925         if (flags & NDR_OUT) {
19926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19927                 if (_ptr_info) {
19928                         NDR_PULL_ALLOC(ndr, r->out.info);
19929                 } else {
19930                         r->out.info = NULL;
19931                 }
19932                 if (r->out.info) {
19933                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19934                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19935                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19937                 }
19938                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19939                         NDR_PULL_ALLOC(ndr, r->out.needed);
19940                 }
19941                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19942                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19946                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19947                 }
19948                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19949                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
19950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
19951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
19952                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19953                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19954                 }
19955                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19956                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
19957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
19958                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
19959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19960         }
19961         return NDR_ERR_SUCCESS;
19962 }
19963
19964 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
19965 {
19966         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
19967         ndr->depth++;
19968         if (flags & NDR_SET_VALUES) {
19969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19970         }
19971         if (flags & NDR_IN) {
19972                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
19973                 ndr->depth++;
19974                 ndr_print_ptr(ndr, "handle", r->in.handle);
19975                 ndr->depth++;
19976                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19977                 ndr->depth--;
19978                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
19979                 ndr->depth++;
19980                 if (r->in.architecture) {
19981                         ndr_print_string(ndr, "architecture", r->in.architecture);
19982                 }
19983                 ndr->depth--;
19984                 ndr_print_uint32(ndr, "level", r->in.level);
19985                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19986                 ndr->depth++;
19987                 if (r->in.buffer) {
19988                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19989                 }
19990                 ndr->depth--;
19991                 ndr_print_uint32(ndr, "offered", r->in.offered);
19992                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
19993                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
19994                 ndr->depth--;
19995         }
19996         if (flags & NDR_OUT) {
19997                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
19998                 ndr->depth++;
19999                 ndr_print_ptr(ndr, "info", r->out.info);
20000                 ndr->depth++;
20001                 if (r->out.info) {
20002                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
20003                 }
20004                 ndr->depth--;
20005                 ndr_print_ptr(ndr, "needed", r->out.needed);
20006                 ndr->depth++;
20007                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20008                 ndr->depth--;
20009                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
20010                 ndr->depth++;
20011                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
20012                 ndr->depth--;
20013                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
20014                 ndr->depth++;
20015                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
20016                 ndr->depth--;
20017                 ndr_print_WERROR(ndr, "result", r->out.result);
20018                 ndr->depth--;
20019         }
20020         ndr->depth--;
20021 }
20022
20023 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20024 {
20025         if (flags & NDR_IN) {
20026         }
20027         if (flags & NDR_OUT) {
20028                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20029         }
20030         return NDR_ERR_SUCCESS;
20031 }
20032
20033 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
20034 {
20035         if (flags & NDR_IN) {
20036         }
20037         if (flags & NDR_OUT) {
20038                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20039         }
20040         return NDR_ERR_SUCCESS;
20041 }
20042
20043 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20044 {
20045         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
20046         ndr->depth++;
20047         if (flags & NDR_SET_VALUES) {
20048                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20049         }
20050         if (flags & NDR_IN) {
20051                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
20052                 ndr->depth++;
20053                 ndr->depth--;
20054         }
20055         if (flags & NDR_OUT) {
20056                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
20057                 ndr->depth++;
20058                 ndr_print_WERROR(ndr, "result", r->out.result);
20059                 ndr->depth--;
20060         }
20061         ndr->depth--;
20062 }
20063
20064 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20065 {
20066         if (flags & NDR_IN) {
20067         }
20068         if (flags & NDR_OUT) {
20069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20070         }
20071         return NDR_ERR_SUCCESS;
20072 }
20073
20074 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
20075 {
20076         if (flags & NDR_IN) {
20077         }
20078         if (flags & NDR_OUT) {
20079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20080         }
20081         return NDR_ERR_SUCCESS;
20082 }
20083
20084 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20085 {
20086         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
20087         ndr->depth++;
20088         if (flags & NDR_SET_VALUES) {
20089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20090         }
20091         if (flags & NDR_IN) {
20092                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
20093                 ndr->depth++;
20094                 ndr->depth--;
20095         }
20096         if (flags & NDR_OUT) {
20097                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
20098                 ndr->depth++;
20099                 ndr_print_WERROR(ndr, "result", r->out.result);
20100                 ndr->depth--;
20101         }
20102         ndr->depth--;
20103 }
20104
20105 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
20106 {
20107         if (flags & NDR_IN) {
20108                 if (r->in.handle == NULL) {
20109                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20110                 }
20111                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20112         }
20113         if (flags & NDR_OUT) {
20114                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20115         }
20116         return NDR_ERR_SUCCESS;
20117 }
20118
20119 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
20120 {
20121         TALLOC_CTX *_mem_save_handle_0;
20122         if (flags & NDR_IN) {
20123                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20124                         NDR_PULL_ALLOC(ndr, r->in.handle);
20125                 }
20126                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20127                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20128                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20129                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20130         }
20131         if (flags & NDR_OUT) {
20132                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20133         }
20134         return NDR_ERR_SUCCESS;
20135 }
20136
20137 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
20138 {
20139         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
20140         ndr->depth++;
20141         if (flags & NDR_SET_VALUES) {
20142                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20143         }
20144         if (flags & NDR_IN) {
20145                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
20146                 ndr->depth++;
20147                 ndr_print_ptr(ndr, "handle", r->in.handle);
20148                 ndr->depth++;
20149                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20150                 ndr->depth--;
20151                 ndr->depth--;
20152         }
20153         if (flags & NDR_OUT) {
20154                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
20155                 ndr->depth++;
20156                 ndr_print_WERROR(ndr, "result", r->out.result);
20157                 ndr->depth--;
20158         }
20159         ndr->depth--;
20160 }
20161
20162 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20163 {
20164         if (flags & NDR_IN) {
20165         }
20166         if (flags & NDR_OUT) {
20167                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20168         }
20169         return NDR_ERR_SUCCESS;
20170 }
20171
20172 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20173 {
20174         if (flags & NDR_IN) {
20175         }
20176         if (flags & NDR_OUT) {
20177                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20178         }
20179         return NDR_ERR_SUCCESS;
20180 }
20181
20182 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20183 {
20184         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20185         ndr->depth++;
20186         if (flags & NDR_SET_VALUES) {
20187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20188         }
20189         if (flags & NDR_IN) {
20190                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20191                 ndr->depth++;
20192                 ndr->depth--;
20193         }
20194         if (flags & NDR_OUT) {
20195                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20196                 ndr->depth++;
20197                 ndr_print_WERROR(ndr, "result", r->out.result);
20198                 ndr->depth--;
20199         }
20200         ndr->depth--;
20201 }
20202
20203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
20204 {
20205         if (flags & NDR_IN) {
20206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20209                 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));
20210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20211                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
20212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20213                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20214                 if (r->in.buffer) {
20215                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20216                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20217                 }
20218         }
20219         if (flags & NDR_OUT) {
20220                 if (r->out.handle == NULL) {
20221                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20222                 }
20223                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20224                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20225         }
20226         return NDR_ERR_SUCCESS;
20227 }
20228
20229 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
20230 {
20231         uint32_t _ptr_buffer;
20232         TALLOC_CTX *_mem_save_buffer_0;
20233         TALLOC_CTX *_mem_save_handle_0;
20234         if (flags & NDR_IN) {
20235                 ZERO_STRUCT(r->out);
20236
20237                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
20238                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
20239                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
20240                         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));
20241                 }
20242                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
20243                 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));
20244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20245                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
20246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20247                 if (r->in.bufsize > 512) {
20248                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20249                 }
20250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20251                 if (_ptr_buffer) {
20252                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20253                 } else {
20254                         r->in.buffer = NULL;
20255                 }
20256                 if (r->in.buffer) {
20257                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20258                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20259                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20260                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20261                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20263                 }
20264                 NDR_PULL_ALLOC(ndr, r->out.handle);
20265                 ZERO_STRUCTP(r->out.handle);
20266                 if (r->in.buffer) {
20267                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20268                 }
20269         }
20270         if (flags & NDR_OUT) {
20271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20272                         NDR_PULL_ALLOC(ndr, r->out.handle);
20273                 }
20274                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20275                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20276                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20279         }
20280         return NDR_ERR_SUCCESS;
20281 }
20282
20283 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
20284 {
20285         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
20286         ndr->depth++;
20287         if (flags & NDR_SET_VALUES) {
20288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20289         }
20290         if (flags & NDR_IN) {
20291                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
20292                 ndr->depth++;
20293                 ndr_print_string(ndr, "server_name", r->in.server_name);
20294                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20295                 ndr_print_winreg_Type(ndr, "type", r->in.type);
20296                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20297                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20298                 ndr->depth++;
20299                 if (r->in.buffer) {
20300                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20301                 }
20302                 ndr->depth--;
20303                 ndr->depth--;
20304         }
20305         if (flags & NDR_OUT) {
20306                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
20307                 ndr->depth++;
20308                 ndr_print_ptr(ndr, "handle", r->out.handle);
20309                 ndr->depth++;
20310                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20311                 ndr->depth--;
20312                 ndr_print_WERROR(ndr, "result", r->out.result);
20313                 ndr->depth--;
20314         }
20315         ndr->depth--;
20316 }
20317
20318 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
20319 {
20320         if (flags & NDR_IN) {
20321                 if (r->in.handle == NULL) {
20322                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20323                 }
20324                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20325                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20328                 if (r->in.buffer) {
20329                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20330                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20331                 }
20332         }
20333         if (flags & NDR_OUT) {
20334                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20335         }
20336         return NDR_ERR_SUCCESS;
20337 }
20338
20339 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
20340 {
20341         uint32_t _ptr_buffer;
20342         TALLOC_CTX *_mem_save_handle_0;
20343         TALLOC_CTX *_mem_save_buffer_0;
20344         if (flags & NDR_IN) {
20345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20346                         NDR_PULL_ALLOC(ndr, r->in.handle);
20347                 }
20348                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20349                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20350                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20352                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20354                 if (r->in.bufsize > 512) {
20355                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20356                 }
20357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20358                 if (_ptr_buffer) {
20359                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20360                 } else {
20361                         r->in.buffer = NULL;
20362                 }
20363                 if (r->in.buffer) {
20364                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20365                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20367                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20368                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20370                 }
20371                 if (r->in.buffer) {
20372                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20373                 }
20374         }
20375         if (flags & NDR_OUT) {
20376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20377         }
20378         return NDR_ERR_SUCCESS;
20379 }
20380
20381 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
20382 {
20383         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
20384         ndr->depth++;
20385         if (flags & NDR_SET_VALUES) {
20386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20387         }
20388         if (flags & NDR_IN) {
20389                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
20390                 ndr->depth++;
20391                 ndr_print_ptr(ndr, "handle", r->in.handle);
20392                 ndr->depth++;
20393                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20394                 ndr->depth--;
20395                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20396                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20397                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20398                 ndr->depth++;
20399                 if (r->in.buffer) {
20400                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20401                 }
20402                 ndr->depth--;
20403                 ndr->depth--;
20404         }
20405         if (flags & NDR_OUT) {
20406                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
20407                 ndr->depth++;
20408                 ndr_print_WERROR(ndr, "result", r->out.result);
20409                 ndr->depth--;
20410         }
20411         ndr->depth--;
20412 }
20413
20414 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
20415 {
20416         if (flags & NDR_IN) {
20417                 if (r->in.handle == NULL) {
20418                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20419                 }
20420                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20421         }
20422         if (flags & NDR_OUT) {
20423                 if (r->out.handle == NULL) {
20424                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20425                 }
20426                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20428         }
20429         return NDR_ERR_SUCCESS;
20430 }
20431
20432 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
20433 {
20434         TALLOC_CTX *_mem_save_handle_0;
20435         if (flags & NDR_IN) {
20436                 ZERO_STRUCT(r->out);
20437
20438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20439                         NDR_PULL_ALLOC(ndr, r->in.handle);
20440                 }
20441                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20445                 NDR_PULL_ALLOC(ndr, r->out.handle);
20446                 *r->out.handle = *r->in.handle;
20447         }
20448         if (flags & NDR_OUT) {
20449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20450                         NDR_PULL_ALLOC(ndr, r->out.handle);
20451                 }
20452                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20453                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20454                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20456                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20457         }
20458         return NDR_ERR_SUCCESS;
20459 }
20460
20461 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
20462 {
20463         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
20464         ndr->depth++;
20465         if (flags & NDR_SET_VALUES) {
20466                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20467         }
20468         if (flags & NDR_IN) {
20469                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
20470                 ndr->depth++;
20471                 ndr_print_ptr(ndr, "handle", r->in.handle);
20472                 ndr->depth++;
20473                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20474                 ndr->depth--;
20475                 ndr->depth--;
20476         }
20477         if (flags & NDR_OUT) {
20478                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
20479                 ndr->depth++;
20480                 ndr_print_ptr(ndr, "handle", r->out.handle);
20481                 ndr->depth++;
20482                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20483                 ndr->depth--;
20484                 ndr_print_WERROR(ndr, "result", r->out.result);
20485                 ndr->depth--;
20486         }
20487         ndr->depth--;
20488 }
20489
20490 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
20491 {
20492         if (flags & NDR_IN) {
20493         }
20494         if (flags & NDR_OUT) {
20495                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20496         }
20497         return NDR_ERR_SUCCESS;
20498 }
20499
20500 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
20501 {
20502         if (flags & NDR_IN) {
20503         }
20504         if (flags & NDR_OUT) {
20505                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20506         }
20507         return NDR_ERR_SUCCESS;
20508 }
20509
20510 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
20511 {
20512         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
20513         ndr->depth++;
20514         if (flags & NDR_SET_VALUES) {
20515                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20516         }
20517         if (flags & NDR_IN) {
20518                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
20519                 ndr->depth++;
20520                 ndr->depth--;
20521         }
20522         if (flags & NDR_OUT) {
20523                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
20524                 ndr->depth++;
20525                 ndr_print_WERROR(ndr, "result", r->out.result);
20526                 ndr->depth--;
20527         }
20528         ndr->depth--;
20529 }
20530
20531 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20532 {
20533         if (flags & NDR_IN) {
20534         }
20535         if (flags & NDR_OUT) {
20536                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20537         }
20538         return NDR_ERR_SUCCESS;
20539 }
20540
20541 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20542 {
20543         if (flags & NDR_IN) {
20544         }
20545         if (flags & NDR_OUT) {
20546                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20547         }
20548         return NDR_ERR_SUCCESS;
20549 }
20550
20551 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20552 {
20553         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
20554         ndr->depth++;
20555         if (flags & NDR_SET_VALUES) {
20556                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20557         }
20558         if (flags & NDR_IN) {
20559                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
20560                 ndr->depth++;
20561                 ndr->depth--;
20562         }
20563         if (flags & NDR_OUT) {
20564                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
20565                 ndr->depth++;
20566                 ndr_print_WERROR(ndr, "result", r->out.result);
20567                 ndr->depth--;
20568         }
20569         ndr->depth--;
20570 }
20571
20572 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
20573 {
20574         if (flags & NDR_IN) {
20575         }
20576         if (flags & NDR_OUT) {
20577                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20578         }
20579         return NDR_ERR_SUCCESS;
20580 }
20581
20582 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
20583 {
20584         if (flags & NDR_IN) {
20585         }
20586         if (flags & NDR_OUT) {
20587                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20588         }
20589         return NDR_ERR_SUCCESS;
20590 }
20591
20592 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
20593 {
20594         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
20595         ndr->depth++;
20596         if (flags & NDR_SET_VALUES) {
20597                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20598         }
20599         if (flags & NDR_IN) {
20600                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
20601                 ndr->depth++;
20602                 ndr->depth--;
20603         }
20604         if (flags & NDR_OUT) {
20605                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
20606                 ndr->depth++;
20607                 ndr_print_WERROR(ndr, "result", r->out.result);
20608                 ndr->depth--;
20609         }
20610         ndr->depth--;
20611 }
20612
20613 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
20614 {
20615         if (flags & NDR_IN) {
20616         }
20617         if (flags & NDR_OUT) {
20618                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20619         }
20620         return NDR_ERR_SUCCESS;
20621 }
20622
20623 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
20624 {
20625         if (flags & NDR_IN) {
20626         }
20627         if (flags & NDR_OUT) {
20628                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20629         }
20630         return NDR_ERR_SUCCESS;
20631 }
20632
20633 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
20634 {
20635         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
20636         ndr->depth++;
20637         if (flags & NDR_SET_VALUES) {
20638                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20639         }
20640         if (flags & NDR_IN) {
20641                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
20642                 ndr->depth++;
20643                 ndr->depth--;
20644         }
20645         if (flags & NDR_OUT) {
20646                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
20647                 ndr->depth++;
20648                 ndr_print_WERROR(ndr, "result", r->out.result);
20649                 ndr->depth--;
20650         }
20651         ndr->depth--;
20652 }
20653
20654 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20655 {
20656         if (flags & NDR_IN) {
20657                 if (r->in.handle == NULL) {
20658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20659                 }
20660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20661                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
20663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
20664                 if (r->in.local_machine) {
20665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20668                         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));
20669                 }
20670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
20672                 if (r->in.notify_options) {
20673                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20674                 }
20675         }
20676         if (flags & NDR_OUT) {
20677                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20678         }
20679         return NDR_ERR_SUCCESS;
20680 }
20681
20682 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20683 {
20684         uint32_t _ptr_local_machine;
20685         uint32_t _ptr_notify_options;
20686         TALLOC_CTX *_mem_save_handle_0;
20687         TALLOC_CTX *_mem_save_local_machine_0;
20688         TALLOC_CTX *_mem_save_notify_options_0;
20689         if (flags & NDR_IN) {
20690                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20691                         NDR_PULL_ALLOC(ndr, r->in.handle);
20692                 }
20693                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20694                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20695                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20696                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20697                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
20699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
20700                 if (_ptr_local_machine) {
20701                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
20702                 } else {
20703                         r->in.local_machine = NULL;
20704                 }
20705                 if (r->in.local_machine) {
20706                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
20707                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
20708                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
20709                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
20710                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
20711                                 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));
20712                         }
20713                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
20714                         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));
20715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
20716                 }
20717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
20719                 if (_ptr_notify_options) {
20720                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
20721                 } else {
20722                         r->in.notify_options = NULL;
20723                 }
20724                 if (r->in.notify_options) {
20725                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
20727                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
20729                 }
20730         }
20731         if (flags & NDR_OUT) {
20732                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20733         }
20734         return NDR_ERR_SUCCESS;
20735 }
20736
20737 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20738 {
20739         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20740         ndr->depth++;
20741         if (flags & NDR_SET_VALUES) {
20742                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20743         }
20744         if (flags & NDR_IN) {
20745                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20746                 ndr->depth++;
20747                 ndr_print_ptr(ndr, "handle", r->in.handle);
20748                 ndr->depth++;
20749                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20750                 ndr->depth--;
20751                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20752                 ndr_print_uint32(ndr, "options", r->in.options);
20753                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
20754                 ndr->depth++;
20755                 if (r->in.local_machine) {
20756                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
20757                 }
20758                 ndr->depth--;
20759                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20760                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
20761                 ndr->depth++;
20762                 if (r->in.notify_options) {
20763                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
20764                 }
20765                 ndr->depth--;
20766                 ndr->depth--;
20767         }
20768         if (flags & NDR_OUT) {
20769                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20770                 ndr->depth++;
20771                 ndr_print_WERROR(ndr, "result", r->out.result);
20772                 ndr->depth--;
20773         }
20774         ndr->depth--;
20775 }
20776
20777 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20778 {
20779         if (flags & NDR_IN) {
20780                 if (r->in.handle == NULL) {
20781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20782                 }
20783                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
20785                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
20787                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20788                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20789         }
20790         if (flags & NDR_OUT) {
20791                 if (r->out.reply_result == NULL) {
20792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20793                 }
20794                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
20795                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20796         }
20797         return NDR_ERR_SUCCESS;
20798 }
20799
20800 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
20801 {
20802         TALLOC_CTX *_mem_save_handle_0;
20803         TALLOC_CTX *_mem_save_reply_result_0;
20804         if (flags & NDR_IN) {
20805                 ZERO_STRUCT(r->out);
20806
20807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20808                         NDR_PULL_ALLOC(ndr, r->in.handle);
20809                 }
20810                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20811                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20812                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
20815                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
20817                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20818                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20819                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
20820                 ZERO_STRUCTP(r->out.reply_result);
20821         }
20822         if (flags & NDR_OUT) {
20823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20824                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
20825                 }
20826                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
20827                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
20828                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
20829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
20830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20831         }
20832         return NDR_ERR_SUCCESS;
20833 }
20834
20835 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20836 {
20837         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
20838         ndr->depth++;
20839         if (flags & NDR_SET_VALUES) {
20840                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20841         }
20842         if (flags & NDR_IN) {
20843                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
20844                 ndr->depth++;
20845                 ndr_print_ptr(ndr, "handle", r->in.handle);
20846                 ndr->depth++;
20847                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20848                 ndr->depth--;
20849                 ndr_print_uint32(ndr, "color", r->in.color);
20850                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20851                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
20852                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
20853                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
20854                 ndr->depth--;
20855         }
20856         if (flags & NDR_OUT) {
20857                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
20858                 ndr->depth++;
20859                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
20860                 ndr->depth++;
20861                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
20862                 ndr->depth--;
20863                 ndr_print_WERROR(ndr, "result", r->out.result);
20864                 ndr->depth--;
20865         }
20866         ndr->depth--;
20867 }
20868
20869 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20870 {
20871         if (flags & NDR_IN) {
20872                 if (r->in.handle == NULL) {
20873                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20874                 }
20875                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
20877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
20878                 if (r->in.options) {
20879                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20880                 }
20881         }
20882         if (flags & NDR_OUT) {
20883                 if (r->out.info == NULL) {
20884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20885                 }
20886                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
20887                 if (*r->out.info) {
20888                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20889                 }
20890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20891         }
20892         return NDR_ERR_SUCCESS;
20893 }
20894
20895 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
20896 {
20897         uint32_t _ptr_options;
20898         uint32_t _ptr_info;
20899         TALLOC_CTX *_mem_save_handle_0;
20900         TALLOC_CTX *_mem_save_options_0;
20901         TALLOC_CTX *_mem_save_info_0;
20902         TALLOC_CTX *_mem_save_info_1;
20903         if (flags & NDR_IN) {
20904                 ZERO_STRUCT(r->out);
20905
20906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20907                         NDR_PULL_ALLOC(ndr, r->in.handle);
20908                 }
20909                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20910                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20911                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
20914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
20915                 if (_ptr_options) {
20916                         NDR_PULL_ALLOC(ndr, r->in.options);
20917                 } else {
20918                         r->in.options = NULL;
20919                 }
20920                 if (r->in.options) {
20921                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20922                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
20923                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
20925                 }
20926                 NDR_PULL_ALLOC(ndr, r->out.info);
20927                 ZERO_STRUCTP(r->out.info);
20928         }
20929         if (flags & NDR_OUT) {
20930                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20931                         NDR_PULL_ALLOC(ndr, r->out.info);
20932                 }
20933                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20934                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
20935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20936                 if (_ptr_info) {
20937                         NDR_PULL_ALLOC(ndr, *r->out.info);
20938                 } else {
20939                         *r->out.info = NULL;
20940                 }
20941                 if (*r->out.info) {
20942                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
20943                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
20944                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20945                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
20946                 }
20947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
20948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20949         }
20950         return NDR_ERR_SUCCESS;
20951 }
20952
20953 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20954 {
20955         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
20956         ndr->depth++;
20957         if (flags & NDR_SET_VALUES) {
20958                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20959         }
20960         if (flags & NDR_IN) {
20961                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
20962                 ndr->depth++;
20963                 ndr_print_ptr(ndr, "handle", r->in.handle);
20964                 ndr->depth++;
20965                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20966                 ndr->depth--;
20967                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
20968                 ndr_print_ptr(ndr, "options", r->in.options);
20969                 ndr->depth++;
20970                 if (r->in.options) {
20971                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
20972                 }
20973                 ndr->depth--;
20974                 ndr->depth--;
20975         }
20976         if (flags & NDR_OUT) {
20977                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
20978                 ndr->depth++;
20979                 ndr_print_ptr(ndr, "info", r->out.info);
20980                 ndr->depth++;
20981                 ndr_print_ptr(ndr, "info", *r->out.info);
20982                 ndr->depth++;
20983                 if (*r->out.info) {
20984                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
20985                 }
20986                 ndr->depth--;
20987                 ndr->depth--;
20988                 ndr_print_WERROR(ndr, "result", r->out.result);
20989                 ndr->depth--;
20990         }
20991         ndr->depth--;
20992 }
20993
20994 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
20995 {
20996         if (flags & NDR_IN) {
20997         }
20998         if (flags & NDR_OUT) {
20999                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21000         }
21001         return NDR_ERR_SUCCESS;
21002 }
21003
21004 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
21005 {
21006         if (flags & NDR_IN) {
21007         }
21008         if (flags & NDR_OUT) {
21009                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21010         }
21011         return NDR_ERR_SUCCESS;
21012 }
21013
21014 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
21015 {
21016         ndr_print_struct(ndr, name, "spoolss_44");
21017         ndr->depth++;
21018         if (flags & NDR_SET_VALUES) {
21019                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21020         }
21021         if (flags & NDR_IN) {
21022                 ndr_print_struct(ndr, "in", "spoolss_44");
21023                 ndr->depth++;
21024                 ndr->depth--;
21025         }
21026         if (flags & NDR_OUT) {
21027                 ndr_print_struct(ndr, "out", "spoolss_44");
21028                 ndr->depth++;
21029                 ndr_print_WERROR(ndr, "result", r->out.result);
21030                 ndr->depth--;
21031         }
21032         ndr->depth--;
21033 }
21034
21035 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
21036 {
21037         if (flags & NDR_IN) {
21038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
21039                 if (r->in.printername) {
21040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21043                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21044                 }
21045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
21046                 if (r->in.datatype) {
21047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21051                 }
21052                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21053                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
21054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21055                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21056                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21057         }
21058         if (flags & NDR_OUT) {
21059                 if (r->out.handle == NULL) {
21060                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21061                 }
21062                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21063                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21064         }
21065         return NDR_ERR_SUCCESS;
21066 }
21067
21068 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
21069 {
21070         uint32_t _ptr_printername;
21071         uint32_t _ptr_datatype;
21072         TALLOC_CTX *_mem_save_printername_0;
21073         TALLOC_CTX *_mem_save_datatype_0;
21074         TALLOC_CTX *_mem_save_handle_0;
21075         if (flags & NDR_IN) {
21076                 ZERO_STRUCT(r->out);
21077
21078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
21079                 if (_ptr_printername) {
21080                         NDR_PULL_ALLOC(ndr, r->in.printername);
21081                 } else {
21082                         r->in.printername = NULL;
21083                 }
21084                 if (r->in.printername) {
21085                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21086                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
21087                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
21088                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
21089                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
21090                                 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));
21091                         }
21092                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
21093                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
21094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
21095                 }
21096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
21097                 if (_ptr_datatype) {
21098                         NDR_PULL_ALLOC(ndr, r->in.datatype);
21099                 } else {
21100                         r->in.datatype = NULL;
21101                 }
21102                 if (r->in.datatype) {
21103                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
21104                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
21105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
21106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
21107                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
21108                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
21109                         }
21110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
21111                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
21112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
21113                 }
21114                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21115                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
21116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21117                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21118                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21119                 NDR_PULL_ALLOC(ndr, r->out.handle);
21120                 ZERO_STRUCTP(r->out.handle);
21121         }
21122         if (flags & NDR_OUT) {
21123                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21124                         NDR_PULL_ALLOC(ndr, r->out.handle);
21125                 }
21126                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21127                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21128                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21129                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21130                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21131         }
21132         return NDR_ERR_SUCCESS;
21133 }
21134
21135 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
21136 {
21137         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
21138         ndr->depth++;
21139         if (flags & NDR_SET_VALUES) {
21140                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21141         }
21142         if (flags & NDR_IN) {
21143                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
21144                 ndr->depth++;
21145                 ndr_print_ptr(ndr, "printername", r->in.printername);
21146                 ndr->depth++;
21147                 if (r->in.printername) {
21148                         ndr_print_string(ndr, "printername", r->in.printername);
21149                 }
21150                 ndr->depth--;
21151                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
21152                 ndr->depth++;
21153                 if (r->in.datatype) {
21154                         ndr_print_string(ndr, "datatype", r->in.datatype);
21155                 }
21156                 ndr->depth--;
21157                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
21158                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
21159                 ndr_print_uint32(ndr, "level", r->in.level);
21160                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
21161                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
21162                 ndr->depth--;
21163         }
21164         if (flags & NDR_OUT) {
21165                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
21166                 ndr->depth++;
21167                 ndr_print_ptr(ndr, "handle", r->out.handle);
21168                 ndr->depth++;
21169                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21170                 ndr->depth--;
21171                 ndr_print_WERROR(ndr, "result", r->out.result);
21172                 ndr->depth--;
21173         }
21174         ndr->depth--;
21175 }
21176
21177 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
21178 {
21179         if (flags & NDR_IN) {
21180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21181                 if (r->in.server) {
21182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21185                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21186                 }
21187                 if (r->in.info_ctr == NULL) {
21188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21189                 }
21190                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21191                 if (r->in.devmode_ctr == NULL) {
21192                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21193                 }
21194                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21195                 if (r->in.secdesc_ctr == NULL) {
21196                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21197                 }
21198                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21199                 if (r->in.userlevel_ctr == NULL) {
21200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21201                 }
21202                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21203         }
21204         if (flags & NDR_OUT) {
21205                 if (r->out.handle == NULL) {
21206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21207                 }
21208                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21209                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21210         }
21211         return NDR_ERR_SUCCESS;
21212 }
21213
21214 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
21215 {
21216         uint32_t _ptr_server;
21217         TALLOC_CTX *_mem_save_server_0;
21218         TALLOC_CTX *_mem_save_info_ctr_0;
21219         TALLOC_CTX *_mem_save_devmode_ctr_0;
21220         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21221         TALLOC_CTX *_mem_save_userlevel_ctr_0;
21222         TALLOC_CTX *_mem_save_handle_0;
21223         if (flags & NDR_IN) {
21224                 ZERO_STRUCT(r->out);
21225
21226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21227                 if (_ptr_server) {
21228                         NDR_PULL_ALLOC(ndr, r->in.server);
21229                 } else {
21230                         r->in.server = NULL;
21231                 }
21232                 if (r->in.server) {
21233                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21234                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21235                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21236                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21237                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21238                                 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));
21239                         }
21240                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21241                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21243                 }
21244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21245                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21246                 }
21247                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21248                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21249                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21251                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21252                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21253                 }
21254                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21255                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21256                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21257                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21258                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21259                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21260                 }
21261                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21262                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21263                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21264                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21265                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21266                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
21267                 }
21268                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21269                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
21270                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21272                 NDR_PULL_ALLOC(ndr, r->out.handle);
21273                 ZERO_STRUCTP(r->out.handle);
21274         }
21275         if (flags & NDR_OUT) {
21276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21277                         NDR_PULL_ALLOC(ndr, r->out.handle);
21278                 }
21279                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21280                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21281                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21283                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21284         }
21285         return NDR_ERR_SUCCESS;
21286 }
21287
21288 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
21289 {
21290         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
21291         ndr->depth++;
21292         if (flags & NDR_SET_VALUES) {
21293                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21294         }
21295         if (flags & NDR_IN) {
21296                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
21297                 ndr->depth++;
21298                 ndr_print_ptr(ndr, "server", r->in.server);
21299                 ndr->depth++;
21300                 if (r->in.server) {
21301                         ndr_print_string(ndr, "server", r->in.server);
21302                 }
21303                 ndr->depth--;
21304                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21305                 ndr->depth++;
21306                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21307                 ndr->depth--;
21308                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21309                 ndr->depth++;
21310                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21311                 ndr->depth--;
21312                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21313                 ndr->depth++;
21314                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21315                 ndr->depth--;
21316                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21317                 ndr->depth++;
21318                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21319                 ndr->depth--;
21320                 ndr->depth--;
21321         }
21322         if (flags & NDR_OUT) {
21323                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
21324                 ndr->depth++;
21325                 ndr_print_ptr(ndr, "handle", r->out.handle);
21326                 ndr->depth++;
21327                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21328                 ndr->depth--;
21329                 ndr_print_WERROR(ndr, "result", r->out.result);
21330                 ndr->depth--;
21331         }
21332         ndr->depth--;
21333 }
21334
21335 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
21336 {
21337         if (flags & NDR_IN) {
21338         }
21339         if (flags & NDR_OUT) {
21340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21341         }
21342         return NDR_ERR_SUCCESS;
21343 }
21344
21345 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
21346 {
21347         if (flags & NDR_IN) {
21348         }
21349         if (flags & NDR_OUT) {
21350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21351         }
21352         return NDR_ERR_SUCCESS;
21353 }
21354
21355 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
21356 {
21357         ndr_print_struct(ndr, name, "spoolss_47");
21358         ndr->depth++;
21359         if (flags & NDR_SET_VALUES) {
21360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21361         }
21362         if (flags & NDR_IN) {
21363                 ndr_print_struct(ndr, "in", "spoolss_47");
21364                 ndr->depth++;
21365                 ndr->depth--;
21366         }
21367         if (flags & NDR_OUT) {
21368                 ndr_print_struct(ndr, "out", "spoolss_47");
21369                 ndr->depth++;
21370                 ndr_print_WERROR(ndr, "result", r->out.result);
21371                 ndr->depth--;
21372         }
21373         ndr->depth--;
21374 }
21375
21376 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
21377 {
21378         if (flags & NDR_IN) {
21379                 if (r->in.handle == NULL) {
21380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21381                 }
21382                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
21384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
21385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
21386         }
21387         if (flags & NDR_OUT) {
21388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
21389                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
21390                 if (r->out.value_needed == NULL) {
21391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21392                 }
21393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
21394                 if (r->out.printerdata_type == NULL) {
21395                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21396                 }
21397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
21398                 if (r->out.buffer == NULL) {
21399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21400                 }
21401                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
21402                 if (r->out.data_needed == NULL) {
21403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21404                 }
21405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
21406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21407         }
21408         return NDR_ERR_SUCCESS;
21409 }
21410
21411 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
21412 {
21413         TALLOC_CTX *_mem_save_handle_0;
21414         TALLOC_CTX *_mem_save_value_needed_0;
21415         TALLOC_CTX *_mem_save_printerdata_type_0;
21416         TALLOC_CTX *_mem_save_buffer_0;
21417         TALLOC_CTX *_mem_save_data_needed_0;
21418         if (flags & NDR_IN) {
21419                 ZERO_STRUCT(r->out);
21420
21421                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21422                         NDR_PULL_ALLOC(ndr, r->in.handle);
21423                 }
21424                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21425                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21426                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
21429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
21430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
21431                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
21432                 ZERO_STRUCTP(r->out.value_needed);
21433                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21434                 ZERO_STRUCTP(r->out.printerdata_type);
21435                 NDR_PULL_ALLOC(ndr, r->out.buffer);
21436                 ZERO_STRUCTP(r->out.buffer);
21437                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
21438                 ZERO_STRUCTP(r->out.data_needed);
21439         }
21440         if (flags & NDR_OUT) {
21441                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
21442                 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));
21443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21444                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
21445                 }
21446                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21447                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
21448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
21449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
21450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21451                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21452                 }
21453                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21454                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
21455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
21456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
21457                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21458                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21459                 }
21460                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21461                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
21462                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
21463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
21464                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21465                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
21466                 }
21467                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21468                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
21469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
21470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
21471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21472                 if (r->out.value_name) {
21473                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
21474                 }
21475         }
21476         return NDR_ERR_SUCCESS;
21477 }
21478
21479 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
21480 {
21481         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
21482         ndr->depth++;
21483         if (flags & NDR_SET_VALUES) {
21484                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21485         }
21486         if (flags & NDR_IN) {
21487                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
21488                 ndr->depth++;
21489                 ndr_print_ptr(ndr, "handle", r->in.handle);
21490                 ndr->depth++;
21491                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21492                 ndr->depth--;
21493                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
21494                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
21495                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
21496                 ndr->depth--;
21497         }
21498         if (flags & NDR_OUT) {
21499                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
21500                 ndr->depth++;
21501                 ndr_print_string(ndr, "value_name", r->out.value_name);
21502                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
21503                 ndr->depth++;
21504                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
21505                 ndr->depth--;
21506                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
21507                 ndr->depth++;
21508                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
21509                 ndr->depth--;
21510                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21511                 ndr->depth++;
21512                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
21513                 ndr->depth--;
21514                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
21515                 ndr->depth++;
21516                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
21517                 ndr->depth--;
21518                 ndr_print_WERROR(ndr, "result", r->out.result);
21519                 ndr->depth--;
21520         }
21521         ndr->depth--;
21522 }
21523
21524 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
21525 {
21526         if (flags & NDR_IN) {
21527                 if (r->in.handle == NULL) {
21528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21529                 }
21530                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21534                 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));
21535         }
21536         if (flags & NDR_OUT) {
21537                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21538         }
21539         return NDR_ERR_SUCCESS;
21540 }
21541
21542 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
21543 {
21544         TALLOC_CTX *_mem_save_handle_0;
21545         if (flags & NDR_IN) {
21546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21547                         NDR_PULL_ALLOC(ndr, r->in.handle);
21548                 }
21549                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21550                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21551                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21553                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21554                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21555                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21556                         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));
21557                 }
21558                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21559                 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));
21560         }
21561         if (flags & NDR_OUT) {
21562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21563         }
21564         return NDR_ERR_SUCCESS;
21565 }
21566
21567 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
21568 {
21569         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
21570         ndr->depth++;
21571         if (flags & NDR_SET_VALUES) {
21572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21573         }
21574         if (flags & NDR_IN) {
21575                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
21576                 ndr->depth++;
21577                 ndr_print_ptr(ndr, "handle", r->in.handle);
21578                 ndr->depth++;
21579                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21580                 ndr->depth--;
21581                 ndr_print_string(ndr, "value_name", r->in.value_name);
21582                 ndr->depth--;
21583         }
21584         if (flags & NDR_OUT) {
21585                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
21586                 ndr->depth++;
21587                 ndr_print_WERROR(ndr, "result", r->out.result);
21588                 ndr->depth--;
21589         }
21590         ndr->depth--;
21591 }
21592
21593 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
21594 {
21595         if (flags & NDR_IN) {
21596         }
21597         if (flags & NDR_OUT) {
21598                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21599         }
21600         return NDR_ERR_SUCCESS;
21601 }
21602
21603 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
21604 {
21605         if (flags & NDR_IN) {
21606         }
21607         if (flags & NDR_OUT) {
21608                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21609         }
21610         return NDR_ERR_SUCCESS;
21611 }
21612
21613 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
21614 {
21615         ndr_print_struct(ndr, name, "spoolss_4a");
21616         ndr->depth++;
21617         if (flags & NDR_SET_VALUES) {
21618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21619         }
21620         if (flags & NDR_IN) {
21621                 ndr_print_struct(ndr, "in", "spoolss_4a");
21622                 ndr->depth++;
21623                 ndr->depth--;
21624         }
21625         if (flags & NDR_OUT) {
21626                 ndr_print_struct(ndr, "out", "spoolss_4a");
21627                 ndr->depth++;
21628                 ndr_print_WERROR(ndr, "result", r->out.result);
21629                 ndr->depth--;
21630         }
21631         ndr->depth--;
21632 }
21633
21634 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
21635 {
21636         if (flags & NDR_IN) {
21637         }
21638         if (flags & NDR_OUT) {
21639                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21640         }
21641         return NDR_ERR_SUCCESS;
21642 }
21643
21644 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
21645 {
21646         if (flags & NDR_IN) {
21647         }
21648         if (flags & NDR_OUT) {
21649                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21650         }
21651         return NDR_ERR_SUCCESS;
21652 }
21653
21654 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
21655 {
21656         ndr_print_struct(ndr, name, "spoolss_4b");
21657         ndr->depth++;
21658         if (flags & NDR_SET_VALUES) {
21659                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21660         }
21661         if (flags & NDR_IN) {
21662                 ndr_print_struct(ndr, "in", "spoolss_4b");
21663                 ndr->depth++;
21664                 ndr->depth--;
21665         }
21666         if (flags & NDR_OUT) {
21667                 ndr_print_struct(ndr, "out", "spoolss_4b");
21668                 ndr->depth++;
21669                 ndr_print_WERROR(ndr, "result", r->out.result);
21670                 ndr->depth--;
21671         }
21672         ndr->depth--;
21673 }
21674
21675 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
21676 {
21677         if (flags & NDR_IN) {
21678         }
21679         if (flags & NDR_OUT) {
21680                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21681         }
21682         return NDR_ERR_SUCCESS;
21683 }
21684
21685 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
21686 {
21687         if (flags & NDR_IN) {
21688         }
21689         if (flags & NDR_OUT) {
21690                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21691         }
21692         return NDR_ERR_SUCCESS;
21693 }
21694
21695 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
21696 {
21697         ndr_print_struct(ndr, name, "spoolss_4c");
21698         ndr->depth++;
21699         if (flags & NDR_SET_VALUES) {
21700                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21701         }
21702         if (flags & NDR_IN) {
21703                 ndr_print_struct(ndr, "in", "spoolss_4c");
21704                 ndr->depth++;
21705                 ndr->depth--;
21706         }
21707         if (flags & NDR_OUT) {
21708                 ndr_print_struct(ndr, "out", "spoolss_4c");
21709                 ndr->depth++;
21710                 ndr_print_WERROR(ndr, "result", r->out.result);
21711                 ndr->depth--;
21712         }
21713         ndr->depth--;
21714 }
21715
21716 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
21717 {
21718         if (flags & NDR_IN) {
21719                 if (r->in.handle == NULL) {
21720                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21721                 }
21722                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21726                 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));
21727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21730                 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));
21731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
21732                 if (r->in.buffer == NULL) {
21733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21734                 }
21735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21736                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21738         }
21739         if (flags & NDR_OUT) {
21740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21741         }
21742         return NDR_ERR_SUCCESS;
21743 }
21744
21745 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
21746 {
21747         TALLOC_CTX *_mem_save_handle_0;
21748         if (flags & NDR_IN) {
21749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21750                         NDR_PULL_ALLOC(ndr, r->in.handle);
21751                 }
21752                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21753                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21754                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21756                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21757                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21758                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21759                         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));
21760                 }
21761                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21762                 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));
21763                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21764                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21765                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21766                         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));
21767                 }
21768                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21769                 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));
21770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
21771                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21772                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21773                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21774                 }
21775                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21777                 if (r->in.buffer) {
21778                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21779                 }
21780         }
21781         if (flags & NDR_OUT) {
21782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21783         }
21784         return NDR_ERR_SUCCESS;
21785 }
21786
21787 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
21788 {
21789         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
21790         ndr->depth++;
21791         if (flags & NDR_SET_VALUES) {
21792                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21793         }
21794         if (flags & NDR_IN) {
21795                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
21796                 ndr->depth++;
21797                 ndr_print_ptr(ndr, "handle", r->in.handle);
21798                 ndr->depth++;
21799                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21800                 ndr->depth--;
21801                 ndr_print_string(ndr, "key_name", r->in.key_name);
21802                 ndr_print_string(ndr, "value_name", r->in.value_name);
21803                 ndr_print_uint32(ndr, "type", r->in.type);
21804                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21805                 ndr->depth++;
21806                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21807                 ndr->depth--;
21808                 ndr_print_uint32(ndr, "offered", r->in.offered);
21809                 ndr->depth--;
21810         }
21811         if (flags & NDR_OUT) {
21812                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
21813                 ndr->depth++;
21814                 ndr_print_WERROR(ndr, "result", r->out.result);
21815                 ndr->depth--;
21816         }
21817         ndr->depth--;
21818 }
21819
21820 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
21821 {
21822         if (flags & NDR_IN) {
21823                 if (r->in.handle == NULL) {
21824                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21825                 }
21826                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21830                 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));
21831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21834                 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));
21835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21836         }
21837         if (flags & NDR_OUT) {
21838                 if (r->out.type == NULL) {
21839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21840                 }
21841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
21842                 if (r->out.buffer == NULL) {
21843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21844                 }
21845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21846                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21847                 if (r->out.needed == NULL) {
21848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21849                 }
21850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21851                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21852         }
21853         return NDR_ERR_SUCCESS;
21854 }
21855
21856 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
21857 {
21858         TALLOC_CTX *_mem_save_handle_0;
21859         TALLOC_CTX *_mem_save_type_0;
21860         TALLOC_CTX *_mem_save_needed_0;
21861         if (flags & NDR_IN) {
21862                 ZERO_STRUCT(r->out);
21863
21864                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21865                         NDR_PULL_ALLOC(ndr, r->in.handle);
21866                 }
21867                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21868                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21869                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21870                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21871                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21872                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21873                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21874                         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));
21875                 }
21876                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21877                 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));
21878                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21879                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21880                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21881                         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));
21882                 }
21883                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21884                 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));
21885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21886                 NDR_PULL_ALLOC(ndr, r->out.type);
21887                 ZERO_STRUCTP(r->out.type);
21888                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
21889                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
21890                 NDR_PULL_ALLOC(ndr, r->out.needed);
21891                 ZERO_STRUCTP(r->out.needed);
21892         }
21893         if (flags & NDR_OUT) {
21894                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21895                         NDR_PULL_ALLOC(ndr, r->out.type);
21896                 }
21897                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21898                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
21900                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21901                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21903                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21904                 }
21905                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21907                         NDR_PULL_ALLOC(ndr, r->out.needed);
21908                 }
21909                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21910                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21913                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21914                 if (r->out.buffer) {
21915                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21916                 }
21917         }
21918         return NDR_ERR_SUCCESS;
21919 }
21920
21921 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
21922 {
21923         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
21924         ndr->depth++;
21925         if (flags & NDR_SET_VALUES) {
21926                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21927         }
21928         if (flags & NDR_IN) {
21929                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
21930                 ndr->depth++;
21931                 ndr_print_ptr(ndr, "handle", r->in.handle);
21932                 ndr->depth++;
21933                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21934                 ndr->depth--;
21935                 ndr_print_string(ndr, "key_name", r->in.key_name);
21936                 ndr_print_string(ndr, "value_name", r->in.value_name);
21937                 ndr_print_uint32(ndr, "offered", r->in.offered);
21938                 ndr->depth--;
21939         }
21940         if (flags & NDR_OUT) {
21941                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
21942                 ndr->depth++;
21943                 ndr_print_ptr(ndr, "type", r->out.type);
21944                 ndr->depth++;
21945                 ndr_print_uint32(ndr, "type", *r->out.type);
21946                 ndr->depth--;
21947                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21948                 ndr->depth++;
21949                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21950                 ndr->depth--;
21951                 ndr_print_ptr(ndr, "needed", r->out.needed);
21952                 ndr->depth++;
21953                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21954                 ndr->depth--;
21955                 ndr_print_WERROR(ndr, "result", r->out.result);
21956                 ndr->depth--;
21957         }
21958         ndr->depth--;
21959 }
21960
21961 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
21962 {
21963         if (flags & NDR_IN) {
21964                 if (r->in.handle == NULL) {
21965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21966                 }
21967                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21971                 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));
21972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21973         }
21974         if (flags & NDR_OUT) {
21975                 if (r->out.buffer == NULL) {
21976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21977                 }
21978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21979                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21980                 if (r->out.needed == NULL) {
21981                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21982                 }
21983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21984                 if (r->out.count == NULL) {
21985                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21986                 }
21987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21988                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21989         }
21990         return NDR_ERR_SUCCESS;
21991 }
21992
21993 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
21994 {
21995         TALLOC_CTX *_mem_save_handle_0;
21996         TALLOC_CTX *_mem_save_needed_0;
21997         TALLOC_CTX *_mem_save_count_0;
21998         if (flags & NDR_IN) {
21999                 ZERO_STRUCT(r->out);
22000
22001                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22002                         NDR_PULL_ALLOC(ndr, r->in.handle);
22003                 }
22004                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22005                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22006                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22008                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22009                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22010                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22011                         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));
22012                 }
22013                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22014                 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));
22015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22016                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
22017                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
22018                 NDR_PULL_ALLOC(ndr, r->out.needed);
22019                 ZERO_STRUCTP(r->out.needed);
22020                 NDR_PULL_ALLOC(ndr, r->out.count);
22021                 ZERO_STRUCTP(r->out.count);
22022         }
22023         if (flags & NDR_OUT) {
22024                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22026                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22027                 }
22028                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22030                         NDR_PULL_ALLOC(ndr, r->out.needed);
22031                 }
22032                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22033                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22036                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22037                         NDR_PULL_ALLOC(ndr, r->out.count);
22038                 }
22039                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22040                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22042                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22043                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22044                 if (r->out.buffer) {
22045                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22046                 }
22047         }
22048         return NDR_ERR_SUCCESS;
22049 }
22050
22051 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
22052 {
22053         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
22054         ndr->depth++;
22055         if (flags & NDR_SET_VALUES) {
22056                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22057         }
22058         if (flags & NDR_IN) {
22059                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
22060                 ndr->depth++;
22061                 ndr_print_ptr(ndr, "handle", r->in.handle);
22062                 ndr->depth++;
22063                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22064                 ndr->depth--;
22065                 ndr_print_string(ndr, "key_name", r->in.key_name);
22066                 ndr_print_uint32(ndr, "offered", r->in.offered);
22067                 ndr->depth--;
22068         }
22069         if (flags & NDR_OUT) {
22070                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
22071                 ndr->depth++;
22072                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22073                 ndr->depth++;
22074                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22075                 ndr->depth--;
22076                 ndr_print_ptr(ndr, "needed", r->out.needed);
22077                 ndr->depth++;
22078                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22079                 ndr->depth--;
22080                 ndr_print_ptr(ndr, "count", r->out.count);
22081                 ndr->depth++;
22082                 ndr_print_uint32(ndr, "count", *r->out.count);
22083                 ndr->depth--;
22084                 ndr_print_WERROR(ndr, "result", r->out.result);
22085                 ndr->depth--;
22086         }
22087         ndr->depth--;
22088 }
22089
22090 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
22091 {
22092         uint32_t cntr_key_buffer_1;
22093         if (flags & NDR_IN) {
22094                 if (r->in.handle == NULL) {
22095                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22096                 }
22097                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22101                 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));
22102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
22103         }
22104         if (flags & NDR_OUT) {
22105                 if (r->out.key_buffer == NULL) {
22106                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22107                 }
22108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
22109                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22110                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
22111                 }
22112                 if (r->out.needed == NULL) {
22113                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22114                 }
22115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22116                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22117         }
22118         return NDR_ERR_SUCCESS;
22119 }
22120
22121 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
22122 {
22123         uint32_t cntr_key_buffer_1;
22124         TALLOC_CTX *_mem_save_handle_0;
22125         TALLOC_CTX *_mem_save_key_buffer_1;
22126         TALLOC_CTX *_mem_save_needed_0;
22127         if (flags & NDR_IN) {
22128                 ZERO_STRUCT(r->out);
22129
22130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22131                         NDR_PULL_ALLOC(ndr, r->in.handle);
22132                 }
22133                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22134                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22135                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22137                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22138                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22139                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22140                         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));
22141                 }
22142                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22143                 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));
22144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
22145                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
22146                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
22147                 NDR_PULL_ALLOC(ndr, r->out.needed);
22148                 ZERO_STRUCTP(r->out.needed);
22149         }
22150         if (flags & NDR_OUT) {
22151                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
22152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22153                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
22154                 }
22155                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
22156                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
22157                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22158                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
22159                 }
22160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
22161                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22162                         NDR_PULL_ALLOC(ndr, r->out.needed);
22163                 }
22164                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22165                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22167                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22168                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22169                 if (r->out.key_buffer) {
22170                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
22171                 }
22172         }
22173         return NDR_ERR_SUCCESS;
22174 }
22175
22176 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
22177 {
22178         uint32_t cntr_key_buffer_1;
22179         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
22180         ndr->depth++;
22181         if (flags & NDR_SET_VALUES) {
22182                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22183         }
22184         if (flags & NDR_IN) {
22185                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
22186                 ndr->depth++;
22187                 ndr_print_ptr(ndr, "handle", r->in.handle);
22188                 ndr->depth++;
22189                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22190                 ndr->depth--;
22191                 ndr_print_string(ndr, "key_name", r->in.key_name);
22192                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
22193                 ndr->depth--;
22194         }
22195         if (flags & NDR_OUT) {
22196                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
22197                 ndr->depth++;
22198                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
22199                 ndr->depth++;
22200                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
22201                 ndr->depth++;
22202                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
22203                         char *idx_1=NULL;
22204                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
22205                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
22206                                 free(idx_1);
22207                         }
22208                 }
22209                 ndr->depth--;
22210                 ndr->depth--;
22211                 ndr_print_ptr(ndr, "needed", r->out.needed);
22212                 ndr->depth++;
22213                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22214                 ndr->depth--;
22215                 ndr_print_WERROR(ndr, "result", r->out.result);
22216                 ndr->depth--;
22217         }
22218         ndr->depth--;
22219 }
22220
22221 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
22222 {
22223         if (flags & NDR_IN) {
22224                 if (r->in.handle == NULL) {
22225                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22226                 }
22227                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22231                 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));
22232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22235                 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));
22236         }
22237         if (flags & NDR_OUT) {
22238                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22239         }
22240         return NDR_ERR_SUCCESS;
22241 }
22242
22243 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
22244 {
22245         TALLOC_CTX *_mem_save_handle_0;
22246         if (flags & NDR_IN) {
22247                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22248                         NDR_PULL_ALLOC(ndr, r->in.handle);
22249                 }
22250                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22251                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22252                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22253                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22254                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22255                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22256                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22257                         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));
22258                 }
22259                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22260                 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));
22261                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22262                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22263                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22264                         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));
22265                 }
22266                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22267                 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));
22268         }
22269         if (flags & NDR_OUT) {
22270                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22271         }
22272         return NDR_ERR_SUCCESS;
22273 }
22274
22275 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
22276 {
22277         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
22278         ndr->depth++;
22279         if (flags & NDR_SET_VALUES) {
22280                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22281         }
22282         if (flags & NDR_IN) {
22283                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
22284                 ndr->depth++;
22285                 ndr_print_ptr(ndr, "handle", r->in.handle);
22286                 ndr->depth++;
22287                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22288                 ndr->depth--;
22289                 ndr_print_string(ndr, "key_name", r->in.key_name);
22290                 ndr_print_string(ndr, "value_name", r->in.value_name);
22291                 ndr->depth--;
22292         }
22293         if (flags & NDR_OUT) {
22294                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
22295                 ndr->depth++;
22296                 ndr_print_WERROR(ndr, "result", r->out.result);
22297                 ndr->depth--;
22298         }
22299         ndr->depth--;
22300 }
22301
22302 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
22303 {
22304         if (flags & NDR_IN) {
22305                 if (r->in.handle == NULL) {
22306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22307                 }
22308                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22312                 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));
22313         }
22314         if (flags & NDR_OUT) {
22315                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22316         }
22317         return NDR_ERR_SUCCESS;
22318 }
22319
22320 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
22321 {
22322         TALLOC_CTX *_mem_save_handle_0;
22323         if (flags & NDR_IN) {
22324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22325                         NDR_PULL_ALLOC(ndr, r->in.handle);
22326                 }
22327                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22328                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22329                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22331                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22332                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22333                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22334                         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));
22335                 }
22336                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22337                 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));
22338         }
22339         if (flags & NDR_OUT) {
22340                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22341         }
22342         return NDR_ERR_SUCCESS;
22343 }
22344
22345 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
22346 {
22347         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
22348         ndr->depth++;
22349         if (flags & NDR_SET_VALUES) {
22350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22351         }
22352         if (flags & NDR_IN) {
22353                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
22354                 ndr->depth++;
22355                 ndr_print_ptr(ndr, "handle", r->in.handle);
22356                 ndr->depth++;
22357                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22358                 ndr->depth--;
22359                 ndr_print_string(ndr, "key_name", r->in.key_name);
22360                 ndr->depth--;
22361         }
22362         if (flags & NDR_OUT) {
22363                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
22364                 ndr->depth++;
22365                 ndr_print_WERROR(ndr, "result", r->out.result);
22366                 ndr->depth--;
22367         }
22368         ndr->depth--;
22369 }
22370
22371 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
22372 {
22373         if (flags & NDR_IN) {
22374         }
22375         if (flags & NDR_OUT) {
22376                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22377         }
22378         return NDR_ERR_SUCCESS;
22379 }
22380
22381 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
22382 {
22383         if (flags & NDR_IN) {
22384         }
22385         if (flags & NDR_OUT) {
22386                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22387         }
22388         return NDR_ERR_SUCCESS;
22389 }
22390
22391 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
22392 {
22393         ndr_print_struct(ndr, name, "spoolss_53");
22394         ndr->depth++;
22395         if (flags & NDR_SET_VALUES) {
22396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22397         }
22398         if (flags & NDR_IN) {
22399                 ndr_print_struct(ndr, "in", "spoolss_53");
22400                 ndr->depth++;
22401                 ndr->depth--;
22402         }
22403         if (flags & NDR_OUT) {
22404                 ndr_print_struct(ndr, "out", "spoolss_53");
22405                 ndr->depth++;
22406                 ndr_print_WERROR(ndr, "result", r->out.result);
22407                 ndr->depth--;
22408         }
22409         ndr->depth--;
22410 }
22411
22412 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22413 {
22414         if (flags & NDR_IN) {
22415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22416                 if (r->in.server) {
22417                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22420                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22421                 }
22422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22425                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22429                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22430                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
22431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
22432         }
22433         if (flags & NDR_OUT) {
22434                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22435         }
22436         return NDR_ERR_SUCCESS;
22437 }
22438
22439 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
22440 {
22441         uint32_t _ptr_server;
22442         TALLOC_CTX *_mem_save_server_0;
22443         if (flags & NDR_IN) {
22444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22445                 if (_ptr_server) {
22446                         NDR_PULL_ALLOC(ndr, r->in.server);
22447                 } else {
22448                         r->in.server = NULL;
22449                 }
22450                 if (r->in.server) {
22451                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22452                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22454                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22455                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22456                                 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));
22457                         }
22458                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22459                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22461                 }
22462                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22463                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22464                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22465                         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));
22466                 }
22467                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22468                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22469                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22470                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22471                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22472                         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));
22473                 }
22474                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22475                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22476                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
22477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
22478         }
22479         if (flags & NDR_OUT) {
22480                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22481         }
22482         return NDR_ERR_SUCCESS;
22483 }
22484
22485 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22486 {
22487         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
22488         ndr->depth++;
22489         if (flags & NDR_SET_VALUES) {
22490                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22491         }
22492         if (flags & NDR_IN) {
22493                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
22494                 ndr->depth++;
22495                 ndr_print_ptr(ndr, "server", r->in.server);
22496                 ndr->depth++;
22497                 if (r->in.server) {
22498                         ndr_print_string(ndr, "server", r->in.server);
22499                 }
22500                 ndr->depth--;
22501                 ndr_print_string(ndr, "architecture", r->in.architecture);
22502                 ndr_print_string(ndr, "driver", r->in.driver);
22503                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
22504                 ndr_print_uint32(ndr, "version", r->in.version);
22505                 ndr->depth--;
22506         }
22507         if (flags & NDR_OUT) {
22508                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
22509                 ndr->depth++;
22510                 ndr_print_WERROR(ndr, "result", r->out.result);
22511                 ndr->depth--;
22512         }
22513         ndr->depth--;
22514 }
22515
22516 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
22517 {
22518         if (flags & NDR_IN) {
22519         }
22520         if (flags & NDR_OUT) {
22521                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22522         }
22523         return NDR_ERR_SUCCESS;
22524 }
22525
22526 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
22527 {
22528         if (flags & NDR_IN) {
22529         }
22530         if (flags & NDR_OUT) {
22531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22532         }
22533         return NDR_ERR_SUCCESS;
22534 }
22535
22536 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
22537 {
22538         ndr_print_struct(ndr, name, "spoolss_55");
22539         ndr->depth++;
22540         if (flags & NDR_SET_VALUES) {
22541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22542         }
22543         if (flags & NDR_IN) {
22544                 ndr_print_struct(ndr, "in", "spoolss_55");
22545                 ndr->depth++;
22546                 ndr->depth--;
22547         }
22548         if (flags & NDR_OUT) {
22549                 ndr_print_struct(ndr, "out", "spoolss_55");
22550                 ndr->depth++;
22551                 ndr_print_WERROR(ndr, "result", r->out.result);
22552                 ndr->depth--;
22553         }
22554         ndr->depth--;
22555 }
22556
22557 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
22558 {
22559         if (flags & NDR_IN) {
22560         }
22561         if (flags & NDR_OUT) {
22562                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22563         }
22564         return NDR_ERR_SUCCESS;
22565 }
22566
22567 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
22568 {
22569         if (flags & NDR_IN) {
22570         }
22571         if (flags & NDR_OUT) {
22572                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22573         }
22574         return NDR_ERR_SUCCESS;
22575 }
22576
22577 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
22578 {
22579         ndr_print_struct(ndr, name, "spoolss_56");
22580         ndr->depth++;
22581         if (flags & NDR_SET_VALUES) {
22582                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22583         }
22584         if (flags & NDR_IN) {
22585                 ndr_print_struct(ndr, "in", "spoolss_56");
22586                 ndr->depth++;
22587                 ndr->depth--;
22588         }
22589         if (flags & NDR_OUT) {
22590                 ndr_print_struct(ndr, "out", "spoolss_56");
22591                 ndr->depth++;
22592                 ndr_print_WERROR(ndr, "result", r->out.result);
22593                 ndr->depth--;
22594         }
22595         ndr->depth--;
22596 }
22597
22598 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
22599 {
22600         if (flags & NDR_IN) {
22601         }
22602         if (flags & NDR_OUT) {
22603                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22604         }
22605         return NDR_ERR_SUCCESS;
22606 }
22607
22608 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
22609 {
22610         if (flags & NDR_IN) {
22611         }
22612         if (flags & NDR_OUT) {
22613                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22614         }
22615         return NDR_ERR_SUCCESS;
22616 }
22617
22618 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
22619 {
22620         ndr_print_struct(ndr, name, "spoolss_57");
22621         ndr->depth++;
22622         if (flags & NDR_SET_VALUES) {
22623                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22624         }
22625         if (flags & NDR_IN) {
22626                 ndr_print_struct(ndr, "in", "spoolss_57");
22627                 ndr->depth++;
22628                 ndr->depth--;
22629         }
22630         if (flags & NDR_OUT) {
22631                 ndr_print_struct(ndr, "out", "spoolss_57");
22632                 ndr->depth++;
22633                 ndr_print_WERROR(ndr, "result", r->out.result);
22634                 ndr->depth--;
22635         }
22636         ndr->depth--;
22637 }
22638
22639 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
22640 {
22641         if (flags & NDR_IN) {
22642                 if (r->in.handle == NULL) {
22643                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22644                 }
22645                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22649                 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));
22650                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
22651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
22652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22653                 if (r->in.status_code == NULL) {
22654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22655                 }
22656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
22657         }
22658         if (flags & NDR_OUT) {
22659                 if (r->out.out_data == NULL) {
22660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22661                 }
22662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22663                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
22664                 if (r->out.needed == NULL) {
22665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22666                 }
22667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22668                 if (r->out.status_code == NULL) {
22669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22670                 }
22671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
22672                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22673         }
22674         return NDR_ERR_SUCCESS;
22675 }
22676
22677 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
22678 {
22679         TALLOC_CTX *_mem_save_handle_0;
22680         TALLOC_CTX *_mem_save_needed_0;
22681         TALLOC_CTX *_mem_save_status_code_0;
22682         if (flags & NDR_IN) {
22683                 ZERO_STRUCT(r->out);
22684
22685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22686                         NDR_PULL_ALLOC(ndr, r->in.handle);
22687                 }
22688                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22692                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
22693                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
22694                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
22695                         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));
22696                 }
22697                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
22698                 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));
22699                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
22700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
22701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
22702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22703                         NDR_PULL_ALLOC(ndr, r->in.status_code);
22704                 }
22705                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22706                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
22707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
22708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22709                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
22710                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
22711                 NDR_PULL_ALLOC(ndr, r->out.needed);
22712                 ZERO_STRUCTP(r->out.needed);
22713                 NDR_PULL_ALLOC(ndr, r->out.status_code);
22714                 *r->out.status_code = *r->in.status_code;
22715         }
22716         if (flags & NDR_OUT) {
22717                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
22718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22719                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
22720                 }
22721                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
22722                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22723                         NDR_PULL_ALLOC(ndr, r->out.needed);
22724                 }
22725                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22726                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22728                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22729                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22730                         NDR_PULL_ALLOC(ndr, r->out.status_code);
22731                 }
22732                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22733                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
22734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
22735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22736                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22737                 if (r->out.out_data) {
22738                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
22739                 }
22740         }
22741         return NDR_ERR_SUCCESS;
22742 }
22743
22744 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
22745 {
22746         ndr_print_struct(ndr, name, "spoolss_XcvData");
22747         ndr->depth++;
22748         if (flags & NDR_SET_VALUES) {
22749                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22750         }
22751         if (flags & NDR_IN) {
22752                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
22753                 ndr->depth++;
22754                 ndr_print_ptr(ndr, "handle", r->in.handle);
22755                 ndr->depth++;
22756                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22757                 ndr->depth--;
22758                 ndr_print_string(ndr, "function_name", r->in.function_name);
22759                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
22760                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
22761                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
22762                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
22763                 ndr->depth++;
22764                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
22765                 ndr->depth--;
22766                 ndr->depth--;
22767         }
22768         if (flags & NDR_OUT) {
22769                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
22770                 ndr->depth++;
22771                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
22772                 ndr->depth++;
22773                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
22774                 ndr->depth--;
22775                 ndr_print_ptr(ndr, "needed", r->out.needed);
22776                 ndr->depth++;
22777                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22778                 ndr->depth--;
22779                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
22780                 ndr->depth++;
22781                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
22782                 ndr->depth--;
22783                 ndr_print_WERROR(ndr, "result", r->out.result);
22784                 ndr->depth--;
22785         }
22786         ndr->depth--;
22787 }
22788
22789 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
22790 {
22791         if (flags & NDR_IN) {
22792                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22793                 if (r->in.servername) {
22794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22796                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22798                 }
22799                 if (r->in.info_ctr == NULL) {
22800                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22801                 }
22802                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22803                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
22804         }
22805         if (flags & NDR_OUT) {
22806                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22807         }
22808         return NDR_ERR_SUCCESS;
22809 }
22810
22811 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
22812 {
22813         uint32_t _ptr_servername;
22814         TALLOC_CTX *_mem_save_servername_0;
22815         TALLOC_CTX *_mem_save_info_ctr_0;
22816         if (flags & NDR_IN) {
22817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22818                 if (_ptr_servername) {
22819                         NDR_PULL_ALLOC(ndr, r->in.servername);
22820                 } else {
22821                         r->in.servername = NULL;
22822                 }
22823                 if (r->in.servername) {
22824                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22825                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22827                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22828                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22829                                 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));
22830                         }
22831                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22832                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22834                 }
22835                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22836                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
22837                 }
22838                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
22839                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
22840                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
22842                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
22843         }
22844         if (flags & NDR_OUT) {
22845                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22846         }
22847         return NDR_ERR_SUCCESS;
22848 }
22849
22850 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
22851 {
22852         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
22853         ndr->depth++;
22854         if (flags & NDR_SET_VALUES) {
22855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22856         }
22857         if (flags & NDR_IN) {
22858                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
22859                 ndr->depth++;
22860                 ndr_print_ptr(ndr, "servername", r->in.servername);
22861                 ndr->depth++;
22862                 if (r->in.servername) {
22863                         ndr_print_string(ndr, "servername", r->in.servername);
22864                 }
22865                 ndr->depth--;
22866                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
22867                 ndr->depth++;
22868                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
22869                 ndr->depth--;
22870                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
22871                 ndr->depth--;
22872         }
22873         if (flags & NDR_OUT) {
22874                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
22875                 ndr->depth++;
22876                 ndr_print_WERROR(ndr, "result", r->out.result);
22877                 ndr->depth--;
22878         }
22879         ndr->depth--;
22880 }
22881
22882 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
22883 {
22884         if (flags & NDR_IN) {
22885         }
22886         if (flags & NDR_OUT) {
22887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22888         }
22889         return NDR_ERR_SUCCESS;
22890 }
22891
22892 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
22893 {
22894         if (flags & NDR_IN) {
22895         }
22896         if (flags & NDR_OUT) {
22897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22898         }
22899         return NDR_ERR_SUCCESS;
22900 }
22901
22902 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
22903 {
22904         ndr_print_struct(ndr, name, "spoolss_5a");
22905         ndr->depth++;
22906         if (flags & NDR_SET_VALUES) {
22907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22908         }
22909         if (flags & NDR_IN) {
22910                 ndr_print_struct(ndr, "in", "spoolss_5a");
22911                 ndr->depth++;
22912                 ndr->depth--;
22913         }
22914         if (flags & NDR_OUT) {
22915                 ndr_print_struct(ndr, "out", "spoolss_5a");
22916                 ndr->depth++;
22917                 ndr_print_WERROR(ndr, "result", r->out.result);
22918                 ndr->depth--;
22919         }
22920         ndr->depth--;
22921 }
22922
22923 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
22924 {
22925         if (flags & NDR_IN) {
22926         }
22927         if (flags & NDR_OUT) {
22928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22929         }
22930         return NDR_ERR_SUCCESS;
22931 }
22932
22933 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
22934 {
22935         if (flags & NDR_IN) {
22936         }
22937         if (flags & NDR_OUT) {
22938                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22939         }
22940         return NDR_ERR_SUCCESS;
22941 }
22942
22943 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
22944 {
22945         ndr_print_struct(ndr, name, "spoolss_5b");
22946         ndr->depth++;
22947         if (flags & NDR_SET_VALUES) {
22948                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22949         }
22950         if (flags & NDR_IN) {
22951                 ndr_print_struct(ndr, "in", "spoolss_5b");
22952                 ndr->depth++;
22953                 ndr->depth--;
22954         }
22955         if (flags & NDR_OUT) {
22956                 ndr_print_struct(ndr, "out", "spoolss_5b");
22957                 ndr->depth++;
22958                 ndr_print_WERROR(ndr, "result", r->out.result);
22959                 ndr->depth--;
22960         }
22961         ndr->depth--;
22962 }
22963
22964 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
22965 {
22966         if (flags & NDR_IN) {
22967         }
22968         if (flags & NDR_OUT) {
22969                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22970         }
22971         return NDR_ERR_SUCCESS;
22972 }
22973
22974 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
22975 {
22976         if (flags & NDR_IN) {
22977         }
22978         if (flags & NDR_OUT) {
22979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22980         }
22981         return NDR_ERR_SUCCESS;
22982 }
22983
22984 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
22985 {
22986         ndr_print_struct(ndr, name, "spoolss_5c");
22987         ndr->depth++;
22988         if (flags & NDR_SET_VALUES) {
22989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22990         }
22991         if (flags & NDR_IN) {
22992                 ndr_print_struct(ndr, "in", "spoolss_5c");
22993                 ndr->depth++;
22994                 ndr->depth--;
22995         }
22996         if (flags & NDR_OUT) {
22997                 ndr_print_struct(ndr, "out", "spoolss_5c");
22998                 ndr->depth++;
22999                 ndr_print_WERROR(ndr, "result", r->out.result);
23000                 ndr->depth--;
23001         }
23002         ndr->depth--;
23003 }
23004
23005 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
23006 {
23007         if (flags & NDR_IN) {
23008         }
23009         if (flags & NDR_OUT) {
23010                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23011         }
23012         return NDR_ERR_SUCCESS;
23013 }
23014
23015 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
23016 {
23017         if (flags & NDR_IN) {
23018         }
23019         if (flags & NDR_OUT) {
23020                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23021         }
23022         return NDR_ERR_SUCCESS;
23023 }
23024
23025 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
23026 {
23027         ndr_print_struct(ndr, name, "spoolss_5d");
23028         ndr->depth++;
23029         if (flags & NDR_SET_VALUES) {
23030                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23031         }
23032         if (flags & NDR_IN) {
23033                 ndr_print_struct(ndr, "in", "spoolss_5d");
23034                 ndr->depth++;
23035                 ndr->depth--;
23036         }
23037         if (flags & NDR_OUT) {
23038                 ndr_print_struct(ndr, "out", "spoolss_5d");
23039                 ndr->depth++;
23040                 ndr_print_WERROR(ndr, "result", r->out.result);
23041                 ndr->depth--;
23042         }
23043         ndr->depth--;
23044 }
23045
23046 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
23047 {
23048         if (flags & NDR_IN) {
23049         }
23050         if (flags & NDR_OUT) {
23051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23052         }
23053         return NDR_ERR_SUCCESS;
23054 }
23055
23056 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
23057 {
23058         if (flags & NDR_IN) {
23059         }
23060         if (flags & NDR_OUT) {
23061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23062         }
23063         return NDR_ERR_SUCCESS;
23064 }
23065
23066 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
23067 {
23068         ndr_print_struct(ndr, name, "spoolss_5e");
23069         ndr->depth++;
23070         if (flags & NDR_SET_VALUES) {
23071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23072         }
23073         if (flags & NDR_IN) {
23074                 ndr_print_struct(ndr, "in", "spoolss_5e");
23075                 ndr->depth++;
23076                 ndr->depth--;
23077         }
23078         if (flags & NDR_OUT) {
23079                 ndr_print_struct(ndr, "out", "spoolss_5e");
23080                 ndr->depth++;
23081                 ndr_print_WERROR(ndr, "result", r->out.result);
23082                 ndr->depth--;
23083         }
23084         ndr->depth--;
23085 }
23086
23087 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
23088 {
23089         if (flags & NDR_IN) {
23090         }
23091         if (flags & NDR_OUT) {
23092                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23093         }
23094         return NDR_ERR_SUCCESS;
23095 }
23096
23097 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
23098 {
23099         if (flags & NDR_IN) {
23100         }
23101         if (flags & NDR_OUT) {
23102                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23103         }
23104         return NDR_ERR_SUCCESS;
23105 }
23106
23107 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
23108 {
23109         ndr_print_struct(ndr, name, "spoolss_5f");
23110         ndr->depth++;
23111         if (flags & NDR_SET_VALUES) {
23112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23113         }
23114         if (flags & NDR_IN) {
23115                 ndr_print_struct(ndr, "in", "spoolss_5f");
23116                 ndr->depth++;
23117                 ndr->depth--;
23118         }
23119         if (flags & NDR_OUT) {
23120                 ndr_print_struct(ndr, "out", "spoolss_5f");
23121                 ndr->depth++;
23122                 ndr_print_WERROR(ndr, "result", r->out.result);
23123                 ndr->depth--;
23124         }
23125         ndr->depth--;
23126 }
23127
23128 static const struct ndr_interface_call spoolss_calls[] = {
23129         {
23130                 "spoolss_EnumPrinters",
23131                 sizeof(struct spoolss_EnumPrinters),
23132                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
23133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
23134                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
23135                 false,
23136         },
23137         {
23138                 "spoolss_OpenPrinter",
23139                 sizeof(struct spoolss_OpenPrinter),
23140                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
23141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
23142                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
23143                 false,
23144         },
23145         {
23146                 "spoolss_SetJob",
23147                 sizeof(struct spoolss_SetJob),
23148                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
23149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
23150                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
23151                 false,
23152         },
23153         {
23154                 "spoolss_GetJob",
23155                 sizeof(struct spoolss_GetJob),
23156                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
23157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
23158                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
23159                 false,
23160         },
23161         {
23162                 "spoolss_EnumJobs",
23163                 sizeof(struct spoolss_EnumJobs),
23164                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
23165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
23166                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
23167                 false,
23168         },
23169         {
23170                 "spoolss_AddPrinter",
23171                 sizeof(struct spoolss_AddPrinter),
23172                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
23173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
23174                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
23175                 false,
23176         },
23177         {
23178                 "spoolss_DeletePrinter",
23179                 sizeof(struct spoolss_DeletePrinter),
23180                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
23181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
23182                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
23183                 false,
23184         },
23185         {
23186                 "spoolss_SetPrinter",
23187                 sizeof(struct spoolss_SetPrinter),
23188                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
23189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
23190                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
23191                 false,
23192         },
23193         {
23194                 "spoolss_GetPrinter",
23195                 sizeof(struct spoolss_GetPrinter),
23196                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
23197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
23198                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
23199                 false,
23200         },
23201         {
23202                 "spoolss_AddPrinterDriver",
23203                 sizeof(struct spoolss_AddPrinterDriver),
23204                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
23205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
23206                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
23207                 false,
23208         },
23209         {
23210                 "spoolss_EnumPrinterDrivers",
23211                 sizeof(struct spoolss_EnumPrinterDrivers),
23212                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
23213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
23214                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
23215                 false,
23216         },
23217         {
23218                 "spoolss_GetPrinterDriver",
23219                 sizeof(struct spoolss_GetPrinterDriver),
23220                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
23221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
23222                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
23223                 false,
23224         },
23225         {
23226                 "spoolss_GetPrinterDriverDirectory",
23227                 sizeof(struct spoolss_GetPrinterDriverDirectory),
23228                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
23229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
23230                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
23231                 false,
23232         },
23233         {
23234                 "spoolss_DeletePrinterDriver",
23235                 sizeof(struct spoolss_DeletePrinterDriver),
23236                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
23237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
23238                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
23239                 false,
23240         },
23241         {
23242                 "spoolss_AddPrintProcessor",
23243                 sizeof(struct spoolss_AddPrintProcessor),
23244                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
23245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
23246                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
23247                 false,
23248         },
23249         {
23250                 "spoolss_EnumPrintProcessors",
23251                 sizeof(struct spoolss_EnumPrintProcessors),
23252                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
23253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
23254                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
23255                 false,
23256         },
23257         {
23258                 "spoolss_GetPrintProcessorDirectory",
23259                 sizeof(struct spoolss_GetPrintProcessorDirectory),
23260                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
23261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
23262                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
23263                 false,
23264         },
23265         {
23266                 "spoolss_StartDocPrinter",
23267                 sizeof(struct spoolss_StartDocPrinter),
23268                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
23269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
23270                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
23271                 false,
23272         },
23273         {
23274                 "spoolss_StartPagePrinter",
23275                 sizeof(struct spoolss_StartPagePrinter),
23276                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
23277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
23278                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
23279                 false,
23280         },
23281         {
23282                 "spoolss_WritePrinter",
23283                 sizeof(struct spoolss_WritePrinter),
23284                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
23285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
23286                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
23287                 false,
23288         },
23289         {
23290                 "spoolss_EndPagePrinter",
23291                 sizeof(struct spoolss_EndPagePrinter),
23292                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
23293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
23294                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
23295                 false,
23296         },
23297         {
23298                 "spoolss_AbortPrinter",
23299                 sizeof(struct spoolss_AbortPrinter),
23300                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
23301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
23302                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
23303                 false,
23304         },
23305         {
23306                 "spoolss_ReadPrinter",
23307                 sizeof(struct spoolss_ReadPrinter),
23308                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
23309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
23310                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
23311                 false,
23312         },
23313         {
23314                 "spoolss_EndDocPrinter",
23315                 sizeof(struct spoolss_EndDocPrinter),
23316                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
23317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
23318                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
23319                 false,
23320         },
23321         {
23322                 "spoolss_AddJob",
23323                 sizeof(struct spoolss_AddJob),
23324                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
23325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
23326                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
23327                 false,
23328         },
23329         {
23330                 "spoolss_ScheduleJob",
23331                 sizeof(struct spoolss_ScheduleJob),
23332                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
23333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
23334                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
23335                 false,
23336         },
23337         {
23338                 "spoolss_GetPrinterData",
23339                 sizeof(struct spoolss_GetPrinterData),
23340                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
23341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
23342                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
23343                 false,
23344         },
23345         {
23346                 "spoolss_SetPrinterData",
23347                 sizeof(struct spoolss_SetPrinterData),
23348                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
23349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
23350                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
23351                 false,
23352         },
23353         {
23354                 "spoolss_WaitForPrinterChange",
23355                 sizeof(struct spoolss_WaitForPrinterChange),
23356                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
23357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
23358                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
23359                 false,
23360         },
23361         {
23362                 "spoolss_ClosePrinter",
23363                 sizeof(struct spoolss_ClosePrinter),
23364                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
23365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
23366                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
23367                 false,
23368         },
23369         {
23370                 "spoolss_AddForm",
23371                 sizeof(struct spoolss_AddForm),
23372                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
23373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
23374                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
23375                 false,
23376         },
23377         {
23378                 "spoolss_DeleteForm",
23379                 sizeof(struct spoolss_DeleteForm),
23380                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
23381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
23382                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
23383                 false,
23384         },
23385         {
23386                 "spoolss_GetForm",
23387                 sizeof(struct spoolss_GetForm),
23388                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
23389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
23390                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
23391                 false,
23392         },
23393         {
23394                 "spoolss_SetForm",
23395                 sizeof(struct spoolss_SetForm),
23396                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
23397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
23398                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
23399                 false,
23400         },
23401         {
23402                 "spoolss_EnumForms",
23403                 sizeof(struct spoolss_EnumForms),
23404                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
23405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
23406                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
23407                 false,
23408         },
23409         {
23410                 "spoolss_EnumPorts",
23411                 sizeof(struct spoolss_EnumPorts),
23412                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
23413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
23414                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
23415                 false,
23416         },
23417         {
23418                 "spoolss_EnumMonitors",
23419                 sizeof(struct spoolss_EnumMonitors),
23420                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
23421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
23422                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
23423                 false,
23424         },
23425         {
23426                 "spoolss_AddPort",
23427                 sizeof(struct spoolss_AddPort),
23428                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
23429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
23430                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
23431                 false,
23432         },
23433         {
23434                 "spoolss_ConfigurePort",
23435                 sizeof(struct spoolss_ConfigurePort),
23436                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
23437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
23438                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
23439                 false,
23440         },
23441         {
23442                 "spoolss_DeletePort",
23443                 sizeof(struct spoolss_DeletePort),
23444                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
23445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
23446                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
23447                 false,
23448         },
23449         {
23450                 "spoolss_CreatePrinterIC",
23451                 sizeof(struct spoolss_CreatePrinterIC),
23452                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
23453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
23454                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
23455                 false,
23456         },
23457         {
23458                 "spoolss_PlayGDIScriptOnPrinterIC",
23459                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
23460                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
23461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
23462                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
23463                 false,
23464         },
23465         {
23466                 "spoolss_DeletePrinterIC",
23467                 sizeof(struct spoolss_DeletePrinterIC),
23468                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
23469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
23470                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
23471                 false,
23472         },
23473         {
23474                 "spoolss_AddPrinterConnection",
23475                 sizeof(struct spoolss_AddPrinterConnection),
23476                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
23477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
23478                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
23479                 false,
23480         },
23481         {
23482                 "spoolss_DeletePrinterConnection",
23483                 sizeof(struct spoolss_DeletePrinterConnection),
23484                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
23485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
23486                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
23487                 false,
23488         },
23489         {
23490                 "spoolss_PrinterMessageBox",
23491                 sizeof(struct spoolss_PrinterMessageBox),
23492                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
23493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
23494                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
23495                 false,
23496         },
23497         {
23498                 "spoolss_AddMonitor",
23499                 sizeof(struct spoolss_AddMonitor),
23500                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
23501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
23502                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
23503                 false,
23504         },
23505         {
23506                 "spoolss_DeleteMonitor",
23507                 sizeof(struct spoolss_DeleteMonitor),
23508                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
23509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
23510                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
23511                 false,
23512         },
23513         {
23514                 "spoolss_DeletePrintProcessor",
23515                 sizeof(struct spoolss_DeletePrintProcessor),
23516                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
23517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
23518                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
23519                 false,
23520         },
23521         {
23522                 "spoolss_AddPrintProvidor",
23523                 sizeof(struct spoolss_AddPrintProvidor),
23524                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
23525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
23526                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
23527                 false,
23528         },
23529         {
23530                 "spoolss_DeletePrintProvidor",
23531                 sizeof(struct spoolss_DeletePrintProvidor),
23532                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
23533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
23534                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
23535                 false,
23536         },
23537         {
23538                 "spoolss_EnumPrintProcDataTypes",
23539                 sizeof(struct spoolss_EnumPrintProcDataTypes),
23540                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
23541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
23542                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
23543                 false,
23544         },
23545         {
23546                 "spoolss_ResetPrinter",
23547                 sizeof(struct spoolss_ResetPrinter),
23548                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
23549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
23550                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
23551                 false,
23552         },
23553         {
23554                 "spoolss_GetPrinterDriver2",
23555                 sizeof(struct spoolss_GetPrinterDriver2),
23556                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
23557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
23558                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
23559                 false,
23560         },
23561         {
23562                 "spoolss_FindFirstPrinterChangeNotification",
23563                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
23564                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
23565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
23566                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
23567                 false,
23568         },
23569         {
23570                 "spoolss_FindNextPrinterChangeNotification",
23571                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
23572                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
23573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
23574                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
23575                 false,
23576         },
23577         {
23578                 "spoolss_FindClosePrinterNotify",
23579                 sizeof(struct spoolss_FindClosePrinterNotify),
23580                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
23581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
23582                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
23583                 false,
23584         },
23585         {
23586                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
23587                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
23588                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23590                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23591                 false,
23592         },
23593         {
23594                 "spoolss_ReplyOpenPrinter",
23595                 sizeof(struct spoolss_ReplyOpenPrinter),
23596                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
23597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
23598                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
23599                 false,
23600         },
23601         {
23602                 "spoolss_RouterReplyPrinter",
23603                 sizeof(struct spoolss_RouterReplyPrinter),
23604                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
23605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
23606                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
23607                 false,
23608         },
23609         {
23610                 "spoolss_ReplyClosePrinter",
23611                 sizeof(struct spoolss_ReplyClosePrinter),
23612                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
23613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
23614                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
23615                 false,
23616         },
23617         {
23618                 "spoolss_AddPortEx",
23619                 sizeof(struct spoolss_AddPortEx),
23620                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
23621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
23622                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
23623                 false,
23624         },
23625         {
23626                 "spoolss_RouterFindFirstPrinterChangeNotification",
23627                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
23628                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
23629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
23630                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
23631                 false,
23632         },
23633         {
23634                 "spoolss_SpoolerInit",
23635                 sizeof(struct spoolss_SpoolerInit),
23636                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
23637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
23638                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
23639                 false,
23640         },
23641         {
23642                 "spoolss_ResetPrinterEx",
23643                 sizeof(struct spoolss_ResetPrinterEx),
23644                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
23645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
23646                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
23647                 false,
23648         },
23649         {
23650                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
23651                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
23652                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23654                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23655                 false,
23656         },
23657         {
23658                 "spoolss_RouterReplyPrinterEx",
23659                 sizeof(struct spoolss_RouterReplyPrinterEx),
23660                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
23661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
23662                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
23663                 false,
23664         },
23665         {
23666                 "spoolss_RouterRefreshPrinterChangeNotify",
23667                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
23668                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
23669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
23670                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
23671                 false,
23672         },
23673         {
23674                 "spoolss_44",
23675                 sizeof(struct spoolss_44),
23676                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
23677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
23678                 (ndr_print_function_t) ndr_print_spoolss_44,
23679                 false,
23680         },
23681         {
23682                 "spoolss_OpenPrinterEx",
23683                 sizeof(struct spoolss_OpenPrinterEx),
23684                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
23685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
23686                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
23687                 false,
23688         },
23689         {
23690                 "spoolss_AddPrinterEx",
23691                 sizeof(struct spoolss_AddPrinterEx),
23692                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
23693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
23694                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
23695                 false,
23696         },
23697         {
23698                 "spoolss_47",
23699                 sizeof(struct spoolss_47),
23700                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
23701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
23702                 (ndr_print_function_t) ndr_print_spoolss_47,
23703                 false,
23704         },
23705         {
23706                 "spoolss_EnumPrinterData",
23707                 sizeof(struct spoolss_EnumPrinterData),
23708                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
23709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
23710                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
23711                 false,
23712         },
23713         {
23714                 "spoolss_DeletePrinterData",
23715                 sizeof(struct spoolss_DeletePrinterData),
23716                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
23717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
23718                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
23719                 false,
23720         },
23721         {
23722                 "spoolss_4a",
23723                 sizeof(struct spoolss_4a),
23724                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
23725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
23726                 (ndr_print_function_t) ndr_print_spoolss_4a,
23727                 false,
23728         },
23729         {
23730                 "spoolss_4b",
23731                 sizeof(struct spoolss_4b),
23732                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
23733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
23734                 (ndr_print_function_t) ndr_print_spoolss_4b,
23735                 false,
23736         },
23737         {
23738                 "spoolss_4c",
23739                 sizeof(struct spoolss_4c),
23740                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
23741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
23742                 (ndr_print_function_t) ndr_print_spoolss_4c,
23743                 false,
23744         },
23745         {
23746                 "spoolss_SetPrinterDataEx",
23747                 sizeof(struct spoolss_SetPrinterDataEx),
23748                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
23749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
23750                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
23751                 false,
23752         },
23753         {
23754                 "spoolss_GetPrinterDataEx",
23755                 sizeof(struct spoolss_GetPrinterDataEx),
23756                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
23757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
23758                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
23759                 false,
23760         },
23761         {
23762                 "spoolss_EnumPrinterDataEx",
23763                 sizeof(struct spoolss_EnumPrinterDataEx),
23764                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
23765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
23766                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
23767                 false,
23768         },
23769         {
23770                 "spoolss_EnumPrinterKey",
23771                 sizeof(struct spoolss_EnumPrinterKey),
23772                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
23773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
23774                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
23775                 false,
23776         },
23777         {
23778                 "spoolss_DeletePrinterDataEx",
23779                 sizeof(struct spoolss_DeletePrinterDataEx),
23780                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
23781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
23782                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
23783                 false,
23784         },
23785         {
23786                 "spoolss_DeletePrinterKey",
23787                 sizeof(struct spoolss_DeletePrinterKey),
23788                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
23789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
23790                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
23791                 false,
23792         },
23793         {
23794                 "spoolss_53",
23795                 sizeof(struct spoolss_53),
23796                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
23797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
23798                 (ndr_print_function_t) ndr_print_spoolss_53,
23799                 false,
23800         },
23801         {
23802                 "spoolss_DeletePrinterDriverEx",
23803                 sizeof(struct spoolss_DeletePrinterDriverEx),
23804                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
23805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
23806                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
23807                 false,
23808         },
23809         {
23810                 "spoolss_55",
23811                 sizeof(struct spoolss_55),
23812                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
23813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
23814                 (ndr_print_function_t) ndr_print_spoolss_55,
23815                 false,
23816         },
23817         {
23818                 "spoolss_56",
23819                 sizeof(struct spoolss_56),
23820                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
23821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
23822                 (ndr_print_function_t) ndr_print_spoolss_56,
23823                 false,
23824         },
23825         {
23826                 "spoolss_57",
23827                 sizeof(struct spoolss_57),
23828                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
23829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
23830                 (ndr_print_function_t) ndr_print_spoolss_57,
23831                 false,
23832         },
23833         {
23834                 "spoolss_XcvData",
23835                 sizeof(struct spoolss_XcvData),
23836                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
23837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
23838                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
23839                 false,
23840         },
23841         {
23842                 "spoolss_AddPrinterDriverEx",
23843                 sizeof(struct spoolss_AddPrinterDriverEx),
23844                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
23845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
23846                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
23847                 false,
23848         },
23849         {
23850                 "spoolss_5a",
23851                 sizeof(struct spoolss_5a),
23852                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
23853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
23854                 (ndr_print_function_t) ndr_print_spoolss_5a,
23855                 false,
23856         },
23857         {
23858                 "spoolss_5b",
23859                 sizeof(struct spoolss_5b),
23860                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
23861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
23862                 (ndr_print_function_t) ndr_print_spoolss_5b,
23863                 false,
23864         },
23865         {
23866                 "spoolss_5c",
23867                 sizeof(struct spoolss_5c),
23868                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
23869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
23870                 (ndr_print_function_t) ndr_print_spoolss_5c,
23871                 false,
23872         },
23873         {
23874                 "spoolss_5d",
23875                 sizeof(struct spoolss_5d),
23876                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
23877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
23878                 (ndr_print_function_t) ndr_print_spoolss_5d,
23879                 false,
23880         },
23881         {
23882                 "spoolss_5e",
23883                 sizeof(struct spoolss_5e),
23884                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
23885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
23886                 (ndr_print_function_t) ndr_print_spoolss_5e,
23887                 false,
23888         },
23889         {
23890                 "spoolss_5f",
23891                 sizeof(struct spoolss_5f),
23892                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
23893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
23894                 (ndr_print_function_t) ndr_print_spoolss_5f,
23895                 false,
23896         },
23897         { NULL, 0, NULL, NULL, NULL, false }
23898 };
23899
23900 static const char * const spoolss_endpoint_strings[] = {
23901         "ncacn_np:[\\pipe\\spoolss]",
23902 };
23903
23904 static const struct ndr_interface_string_array spoolss_endpoints = {
23905         .count  = 1,
23906         .names  = spoolss_endpoint_strings
23907 };
23908
23909 static const char * const spoolss_authservice_strings[] = {
23910         "host",
23911 };
23912
23913 static const struct ndr_interface_string_array spoolss_authservices = {
23914         .count  = 1,
23915         .names  = spoolss_authservice_strings
23916 };
23917
23918
23919 const struct ndr_interface_table ndr_table_spoolss = {
23920         .name           = "spoolss",
23921         .syntax_id      = {
23922                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
23923                 NDR_SPOOLSS_VERSION
23924         },
23925         .helpstring     = NDR_SPOOLSS_HELPSTRING,
23926         .num_calls      = 96,
23927         .calls          = spoolss_calls,
23928         .endpoints      = &spoolss_endpoints,
23929         .authservices   = &spoolss_authservices
23930 };
23931