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 _PUBLIC_ 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 _PUBLIC_ 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_date));
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_date));
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_date", r->driver_date);
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_date));
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_date));
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_date", r->driver_date);
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 _PUBLIC_ 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 _PUBLIC_ 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 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
7229 {
7230         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
7231 }
7232
7233 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
7234 {
7235         if (ndr_flags & NDR_SCALARS) {
7236                 NDR_CHECK(ndr_push_align(ndr, 4));
7237                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7238                 {
7239                         uint32_t _flags_save_string = ndr->flags;
7240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7242                         ndr->flags = _flags_save_string;
7243                 }
7244                 {
7245                         uint32_t _flags_save_string = ndr->flags;
7246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7247                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7248                         ndr->flags = _flags_save_string;
7249                 }
7250                 {
7251                         uint32_t _flags_save_string = ndr->flags;
7252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7254                         ndr->flags = _flags_save_string;
7255                 }
7256                 {
7257                         uint32_t _flags_save_string = ndr->flags;
7258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7260                         ndr->flags = _flags_save_string;
7261                 }
7262                 {
7263                         uint32_t _flags_save_string = ndr->flags;
7264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7266                         ndr->flags = _flags_save_string;
7267                 }
7268         }
7269         if (ndr_flags & NDR_BUFFERS) {
7270                 {
7271                         uint32_t _flags_save_string = ndr->flags;
7272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7273                         if (r->driver_name) {
7274                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7275                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7276                         }
7277                         ndr->flags = _flags_save_string;
7278                 }
7279                 {
7280                         uint32_t _flags_save_string = ndr->flags;
7281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7282                         if (r->architecture) {
7283                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7284                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7285                         }
7286                         ndr->flags = _flags_save_string;
7287                 }
7288                 {
7289                         uint32_t _flags_save_string = ndr->flags;
7290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7291                         if (r->driver_path) {
7292                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7293                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7294                         }
7295                         ndr->flags = _flags_save_string;
7296                 }
7297                 {
7298                         uint32_t _flags_save_string = ndr->flags;
7299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7300                         if (r->data_file) {
7301                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7303                         }
7304                         ndr->flags = _flags_save_string;
7305                 }
7306                 {
7307                         uint32_t _flags_save_string = ndr->flags;
7308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7309                         if (r->config_file) {
7310                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7311                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7312                         }
7313                         ndr->flags = _flags_save_string;
7314                 }
7315         }
7316         return NDR_ERR_SUCCESS;
7317 }
7318
7319 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
7320 {
7321         uint32_t _ptr_driver_name;
7322         TALLOC_CTX *_mem_save_driver_name_0;
7323         uint32_t _ptr_architecture;
7324         TALLOC_CTX *_mem_save_architecture_0;
7325         uint32_t _ptr_driver_path;
7326         TALLOC_CTX *_mem_save_driver_path_0;
7327         uint32_t _ptr_data_file;
7328         TALLOC_CTX *_mem_save_data_file_0;
7329         uint32_t _ptr_config_file;
7330         TALLOC_CTX *_mem_save_config_file_0;
7331         if (ndr_flags & NDR_SCALARS) {
7332                 NDR_CHECK(ndr_pull_align(ndr, 4));
7333                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7334                 {
7335                         uint32_t _flags_save_string = ndr->flags;
7336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7337                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7338                         if (_ptr_driver_name) {
7339                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7340                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7341                         } else {
7342                                 r->driver_name = NULL;
7343                         }
7344                         ndr->flags = _flags_save_string;
7345                 }
7346                 {
7347                         uint32_t _flags_save_string = ndr->flags;
7348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7349                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7350                         if (_ptr_architecture) {
7351                                 NDR_PULL_ALLOC(ndr, r->architecture);
7352                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7353                         } else {
7354                                 r->architecture = NULL;
7355                         }
7356                         ndr->flags = _flags_save_string;
7357                 }
7358                 {
7359                         uint32_t _flags_save_string = ndr->flags;
7360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7361                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7362                         if (_ptr_driver_path) {
7363                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7364                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7365                         } else {
7366                                 r->driver_path = NULL;
7367                         }
7368                         ndr->flags = _flags_save_string;
7369                 }
7370                 {
7371                         uint32_t _flags_save_string = ndr->flags;
7372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7373                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7374                         if (_ptr_data_file) {
7375                                 NDR_PULL_ALLOC(ndr, r->data_file);
7376                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7377                         } else {
7378                                 r->data_file = NULL;
7379                         }
7380                         ndr->flags = _flags_save_string;
7381                 }
7382                 {
7383                         uint32_t _flags_save_string = ndr->flags;
7384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7386                         if (_ptr_config_file) {
7387                                 NDR_PULL_ALLOC(ndr, r->config_file);
7388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7389                         } else {
7390                                 r->config_file = NULL;
7391                         }
7392                         ndr->flags = _flags_save_string;
7393                 }
7394         }
7395         if (ndr_flags & NDR_BUFFERS) {
7396                 {
7397                         uint32_t _flags_save_string = ndr->flags;
7398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7399                         if (r->driver_name) {
7400                                 uint32_t _relative_save_offset;
7401                                 _relative_save_offset = ndr->offset;
7402                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7403                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7404                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7405                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7406                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7407                                 ndr->offset = _relative_save_offset;
7408                         }
7409                         ndr->flags = _flags_save_string;
7410                 }
7411                 {
7412                         uint32_t _flags_save_string = ndr->flags;
7413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7414                         if (r->architecture) {
7415                                 uint32_t _relative_save_offset;
7416                                 _relative_save_offset = ndr->offset;
7417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7418                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7419                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7422                                 ndr->offset = _relative_save_offset;
7423                         }
7424                         ndr->flags = _flags_save_string;
7425                 }
7426                 {
7427                         uint32_t _flags_save_string = ndr->flags;
7428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7429                         if (r->driver_path) {
7430                                 uint32_t _relative_save_offset;
7431                                 _relative_save_offset = ndr->offset;
7432                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7433                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7434                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7435                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7436                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7437                                 ndr->offset = _relative_save_offset;
7438                         }
7439                         ndr->flags = _flags_save_string;
7440                 }
7441                 {
7442                         uint32_t _flags_save_string = ndr->flags;
7443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7444                         if (r->data_file) {
7445                                 uint32_t _relative_save_offset;
7446                                 _relative_save_offset = ndr->offset;
7447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7448                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7449                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7452                                 ndr->offset = _relative_save_offset;
7453                         }
7454                         ndr->flags = _flags_save_string;
7455                 }
7456                 {
7457                         uint32_t _flags_save_string = ndr->flags;
7458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7459                         if (r->config_file) {
7460                                 uint32_t _relative_save_offset;
7461                                 _relative_save_offset = ndr->offset;
7462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7463                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7464                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7467                                 ndr->offset = _relative_save_offset;
7468                         }
7469                         ndr->flags = _flags_save_string;
7470                 }
7471         }
7472         return NDR_ERR_SUCCESS;
7473 }
7474
7475 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
7476 {
7477         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
7478         ndr->depth++;
7479         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7480         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7481         ndr->depth++;
7482         if (r->driver_name) {
7483                 ndr_print_string(ndr, "driver_name", r->driver_name);
7484         }
7485         ndr->depth--;
7486         ndr_print_ptr(ndr, "architecture", r->architecture);
7487         ndr->depth++;
7488         if (r->architecture) {
7489                 ndr_print_string(ndr, "architecture", r->architecture);
7490         }
7491         ndr->depth--;
7492         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7493         ndr->depth++;
7494         if (r->driver_path) {
7495                 ndr_print_string(ndr, "driver_path", r->driver_path);
7496         }
7497         ndr->depth--;
7498         ndr_print_ptr(ndr, "data_file", r->data_file);
7499         ndr->depth++;
7500         if (r->data_file) {
7501                 ndr_print_string(ndr, "data_file", r->data_file);
7502         }
7503         ndr->depth--;
7504         ndr_print_ptr(ndr, "config_file", r->config_file);
7505         ndr->depth++;
7506         if (r->config_file) {
7507                 ndr_print_string(ndr, "config_file", r->config_file);
7508         }
7509         ndr->depth--;
7510         ndr->depth--;
7511 }
7512
7513 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
7514 {
7515         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
7516 }
7517
7518 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
7519 {
7520         if (ndr_flags & NDR_SCALARS) {
7521                 NDR_CHECK(ndr_push_align(ndr, 4));
7522                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7523                 {
7524                         uint32_t _flags_save_string = ndr->flags;
7525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7526                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7527                         ndr->flags = _flags_save_string;
7528                 }
7529                 {
7530                         uint32_t _flags_save_string = ndr->flags;
7531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7533                         ndr->flags = _flags_save_string;
7534                 }
7535                 {
7536                         uint32_t _flags_save_string = ndr->flags;
7537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7539                         ndr->flags = _flags_save_string;
7540                 }
7541                 {
7542                         uint32_t _flags_save_string = ndr->flags;
7543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7545                         ndr->flags = _flags_save_string;
7546                 }
7547                 {
7548                         uint32_t _flags_save_string = ndr->flags;
7549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7551                         ndr->flags = _flags_save_string;
7552                 }
7553                 {
7554                         uint32_t _flags_save_string = ndr->flags;
7555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7556                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
7557                         ndr->flags = _flags_save_string;
7558                 }
7559                 {
7560                         uint32_t _flags_save_string_array = ndr->flags;
7561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
7563                         ndr->flags = _flags_save_string_array;
7564                 }
7565                 {
7566                         uint32_t _flags_save_string = ndr->flags;
7567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7568                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7569                         ndr->flags = _flags_save_string;
7570                 }
7571                 {
7572                         uint32_t _flags_save_string = ndr->flags;
7573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7574                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
7575                         ndr->flags = _flags_save_string;
7576                 }
7577         }
7578         if (ndr_flags & NDR_BUFFERS) {
7579                 {
7580                         uint32_t _flags_save_string = ndr->flags;
7581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7582                         if (r->driver_name) {
7583                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7584                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7585                         }
7586                         ndr->flags = _flags_save_string;
7587                 }
7588                 {
7589                         uint32_t _flags_save_string = ndr->flags;
7590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7591                         if (r->architecture) {
7592                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7593                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7594                         }
7595                         ndr->flags = _flags_save_string;
7596                 }
7597                 {
7598                         uint32_t _flags_save_string = ndr->flags;
7599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7600                         if (r->driver_path) {
7601                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7602                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7603                         }
7604                         ndr->flags = _flags_save_string;
7605                 }
7606                 {
7607                         uint32_t _flags_save_string = ndr->flags;
7608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7609                         if (r->data_file) {
7610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7612                         }
7613                         ndr->flags = _flags_save_string;
7614                 }
7615                 {
7616                         uint32_t _flags_save_string = ndr->flags;
7617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7618                         if (r->config_file) {
7619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7621                         }
7622                         ndr->flags = _flags_save_string;
7623                 }
7624                 {
7625                         uint32_t _flags_save_string = ndr->flags;
7626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7627                         if (r->help_file) {
7628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
7629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
7630                         }
7631                         ndr->flags = _flags_save_string;
7632                 }
7633                 {
7634                         uint32_t _flags_save_string_array = ndr->flags;
7635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7636                         if (r->dependent_files) {
7637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
7638                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
7639                         }
7640                         ndr->flags = _flags_save_string_array;
7641                 }
7642                 {
7643                         uint32_t _flags_save_string = ndr->flags;
7644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7645                         if (r->monitor_name) {
7646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7648                         }
7649                         ndr->flags = _flags_save_string;
7650                 }
7651                 {
7652                         uint32_t _flags_save_string = ndr->flags;
7653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7654                         if (r->default_datatype) {
7655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
7656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
7657                         }
7658                         ndr->flags = _flags_save_string;
7659                 }
7660         }
7661         return NDR_ERR_SUCCESS;
7662 }
7663
7664 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
7665 {
7666         uint32_t _ptr_driver_name;
7667         TALLOC_CTX *_mem_save_driver_name_0;
7668         uint32_t _ptr_architecture;
7669         TALLOC_CTX *_mem_save_architecture_0;
7670         uint32_t _ptr_driver_path;
7671         TALLOC_CTX *_mem_save_driver_path_0;
7672         uint32_t _ptr_data_file;
7673         TALLOC_CTX *_mem_save_data_file_0;
7674         uint32_t _ptr_config_file;
7675         TALLOC_CTX *_mem_save_config_file_0;
7676         uint32_t _ptr_help_file;
7677         TALLOC_CTX *_mem_save_help_file_0;
7678         uint32_t _ptr_dependent_files;
7679         TALLOC_CTX *_mem_save_dependent_files_0;
7680         uint32_t _ptr_monitor_name;
7681         TALLOC_CTX *_mem_save_monitor_name_0;
7682         uint32_t _ptr_default_datatype;
7683         TALLOC_CTX *_mem_save_default_datatype_0;
7684         if (ndr_flags & NDR_SCALARS) {
7685                 NDR_CHECK(ndr_pull_align(ndr, 4));
7686                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7687                 {
7688                         uint32_t _flags_save_string = ndr->flags;
7689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7690                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7691                         if (_ptr_driver_name) {
7692                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7693                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7694                         } else {
7695                                 r->driver_name = NULL;
7696                         }
7697                         ndr->flags = _flags_save_string;
7698                 }
7699                 {
7700                         uint32_t _flags_save_string = ndr->flags;
7701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7702                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7703                         if (_ptr_architecture) {
7704                                 NDR_PULL_ALLOC(ndr, r->architecture);
7705                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7706                         } else {
7707                                 r->architecture = NULL;
7708                         }
7709                         ndr->flags = _flags_save_string;
7710                 }
7711                 {
7712                         uint32_t _flags_save_string = ndr->flags;
7713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7714                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7715                         if (_ptr_driver_path) {
7716                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7717                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7718                         } else {
7719                                 r->driver_path = NULL;
7720                         }
7721                         ndr->flags = _flags_save_string;
7722                 }
7723                 {
7724                         uint32_t _flags_save_string = ndr->flags;
7725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7726                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7727                         if (_ptr_data_file) {
7728                                 NDR_PULL_ALLOC(ndr, r->data_file);
7729                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7730                         } else {
7731                                 r->data_file = NULL;
7732                         }
7733                         ndr->flags = _flags_save_string;
7734                 }
7735                 {
7736                         uint32_t _flags_save_string = ndr->flags;
7737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7738                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7739                         if (_ptr_config_file) {
7740                                 NDR_PULL_ALLOC(ndr, r->config_file);
7741                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7742                         } else {
7743                                 r->config_file = NULL;
7744                         }
7745                         ndr->flags = _flags_save_string;
7746                 }
7747                 {
7748                         uint32_t _flags_save_string = ndr->flags;
7749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7750                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7751                         if (_ptr_help_file) {
7752                                 NDR_PULL_ALLOC(ndr, r->help_file);
7753                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7754                         } else {
7755                                 r->help_file = NULL;
7756                         }
7757                         ndr->flags = _flags_save_string;
7758                 }
7759                 {
7760                         uint32_t _flags_save_string_array = ndr->flags;
7761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7762                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7763                         if (_ptr_dependent_files) {
7764                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7765                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7766                         } else {
7767                                 r->dependent_files = NULL;
7768                         }
7769                         ndr->flags = _flags_save_string_array;
7770                 }
7771                 {
7772                         uint32_t _flags_save_string = ndr->flags;
7773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7774                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7775                         if (_ptr_monitor_name) {
7776                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7777                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7778                         } else {
7779                                 r->monitor_name = NULL;
7780                         }
7781                         ndr->flags = _flags_save_string;
7782                 }
7783                 {
7784                         uint32_t _flags_save_string = ndr->flags;
7785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7786                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7787                         if (_ptr_default_datatype) {
7788                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7789                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7790                         } else {
7791                                 r->default_datatype = NULL;
7792                         }
7793                         ndr->flags = _flags_save_string;
7794                 }
7795         }
7796         if (ndr_flags & NDR_BUFFERS) {
7797                 {
7798                         uint32_t _flags_save_string = ndr->flags;
7799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7800                         if (r->driver_name) {
7801                                 uint32_t _relative_save_offset;
7802                                 _relative_save_offset = ndr->offset;
7803                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7804                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7805                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7806                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7807                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7808                                 ndr->offset = _relative_save_offset;
7809                         }
7810                         ndr->flags = _flags_save_string;
7811                 }
7812                 {
7813                         uint32_t _flags_save_string = ndr->flags;
7814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7815                         if (r->architecture) {
7816                                 uint32_t _relative_save_offset;
7817                                 _relative_save_offset = ndr->offset;
7818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7819                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7820                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7821                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7823                                 ndr->offset = _relative_save_offset;
7824                         }
7825                         ndr->flags = _flags_save_string;
7826                 }
7827                 {
7828                         uint32_t _flags_save_string = ndr->flags;
7829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7830                         if (r->driver_path) {
7831                                 uint32_t _relative_save_offset;
7832                                 _relative_save_offset = ndr->offset;
7833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7834                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7835                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7838                                 ndr->offset = _relative_save_offset;
7839                         }
7840                         ndr->flags = _flags_save_string;
7841                 }
7842                 {
7843                         uint32_t _flags_save_string = ndr->flags;
7844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7845                         if (r->data_file) {
7846                                 uint32_t _relative_save_offset;
7847                                 _relative_save_offset = ndr->offset;
7848                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7849                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7850                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7851                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7852                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7853                                 ndr->offset = _relative_save_offset;
7854                         }
7855                         ndr->flags = _flags_save_string;
7856                 }
7857                 {
7858                         uint32_t _flags_save_string = ndr->flags;
7859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7860                         if (r->config_file) {
7861                                 uint32_t _relative_save_offset;
7862                                 _relative_save_offset = ndr->offset;
7863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7864                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7865                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7868                                 ndr->offset = _relative_save_offset;
7869                         }
7870                         ndr->flags = _flags_save_string;
7871                 }
7872                 {
7873                         uint32_t _flags_save_string = ndr->flags;
7874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7875                         if (r->help_file) {
7876                                 uint32_t _relative_save_offset;
7877                                 _relative_save_offset = ndr->offset;
7878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7879                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7880                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7883                                 ndr->offset = _relative_save_offset;
7884                         }
7885                         ndr->flags = _flags_save_string;
7886                 }
7887                 {
7888                         uint32_t _flags_save_string_array = ndr->flags;
7889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7890                         if (r->dependent_files) {
7891                                 uint32_t _relative_save_offset;
7892                                 _relative_save_offset = ndr->offset;
7893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7894                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7895                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7896                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7898                                 ndr->offset = _relative_save_offset;
7899                         }
7900                         ndr->flags = _flags_save_string_array;
7901                 }
7902                 {
7903                         uint32_t _flags_save_string = ndr->flags;
7904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7905                         if (r->monitor_name) {
7906                                 uint32_t _relative_save_offset;
7907                                 _relative_save_offset = ndr->offset;
7908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7909                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7910                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7913                                 ndr->offset = _relative_save_offset;
7914                         }
7915                         ndr->flags = _flags_save_string;
7916                 }
7917                 {
7918                         uint32_t _flags_save_string = ndr->flags;
7919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7920                         if (r->default_datatype) {
7921                                 uint32_t _relative_save_offset;
7922                                 _relative_save_offset = ndr->offset;
7923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7924                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7925                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7928                                 ndr->offset = _relative_save_offset;
7929                         }
7930                         ndr->flags = _flags_save_string;
7931                 }
7932         }
7933         return NDR_ERR_SUCCESS;
7934 }
7935
7936 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
7937 {
7938         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
7939         ndr->depth++;
7940         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7941         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7942         ndr->depth++;
7943         if (r->driver_name) {
7944                 ndr_print_string(ndr, "driver_name", r->driver_name);
7945         }
7946         ndr->depth--;
7947         ndr_print_ptr(ndr, "architecture", r->architecture);
7948         ndr->depth++;
7949         if (r->architecture) {
7950                 ndr_print_string(ndr, "architecture", r->architecture);
7951         }
7952         ndr->depth--;
7953         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7954         ndr->depth++;
7955         if (r->driver_path) {
7956                 ndr_print_string(ndr, "driver_path", r->driver_path);
7957         }
7958         ndr->depth--;
7959         ndr_print_ptr(ndr, "data_file", r->data_file);
7960         ndr->depth++;
7961         if (r->data_file) {
7962                 ndr_print_string(ndr, "data_file", r->data_file);
7963         }
7964         ndr->depth--;
7965         ndr_print_ptr(ndr, "config_file", r->config_file);
7966         ndr->depth++;
7967         if (r->config_file) {
7968                 ndr_print_string(ndr, "config_file", r->config_file);
7969         }
7970         ndr->depth--;
7971         ndr_print_ptr(ndr, "help_file", r->help_file);
7972         ndr->depth++;
7973         if (r->help_file) {
7974                 ndr_print_string(ndr, "help_file", r->help_file);
7975         }
7976         ndr->depth--;
7977         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7978         ndr->depth++;
7979         if (r->dependent_files) {
7980                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7981         }
7982         ndr->depth--;
7983         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7984         ndr->depth++;
7985         if (r->monitor_name) {
7986                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7987         }
7988         ndr->depth--;
7989         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7990         ndr->depth++;
7991         if (r->default_datatype) {
7992                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7993         }
7994         ndr->depth--;
7995         ndr->depth--;
7996 }
7997
7998 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
7999 {
8000         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
8001 }
8002
8003 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
8004 {
8005         if (ndr_flags & NDR_SCALARS) {
8006                 NDR_CHECK(ndr_push_align(ndr, 4));
8007                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8008                 {
8009                         uint32_t _flags_save_string = ndr->flags;
8010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8012                         ndr->flags = _flags_save_string;
8013                 }
8014                 {
8015                         uint32_t _flags_save_string = ndr->flags;
8016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8017                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8018                         ndr->flags = _flags_save_string;
8019                 }
8020                 {
8021                         uint32_t _flags_save_string = ndr->flags;
8022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8023                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8024                         ndr->flags = _flags_save_string;
8025                 }
8026                 {
8027                         uint32_t _flags_save_string = ndr->flags;
8028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8029                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8030                         ndr->flags = _flags_save_string;
8031                 }
8032                 {
8033                         uint32_t _flags_save_string = ndr->flags;
8034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8035                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8036                         ndr->flags = _flags_save_string;
8037                 }
8038                 {
8039                         uint32_t _flags_save_string = ndr->flags;
8040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8041                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8042                         ndr->flags = _flags_save_string;
8043                 }
8044                 {
8045                         uint32_t _flags_save_string_array = ndr->flags;
8046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8047                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8048                         ndr->flags = _flags_save_string_array;
8049                 }
8050                 {
8051                         uint32_t _flags_save_string = ndr->flags;
8052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8053                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8054                         ndr->flags = _flags_save_string;
8055                 }
8056                 {
8057                         uint32_t _flags_save_string = ndr->flags;
8058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8059                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8060                         ndr->flags = _flags_save_string;
8061                 }
8062                 {
8063                         uint32_t _flags_save_string_array = ndr->flags;
8064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8065                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8066                         ndr->flags = _flags_save_string_array;
8067                 }
8068         }
8069         if (ndr_flags & NDR_BUFFERS) {
8070                 {
8071                         uint32_t _flags_save_string = ndr->flags;
8072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8073                         if (r->driver_name) {
8074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8076                         }
8077                         ndr->flags = _flags_save_string;
8078                 }
8079                 {
8080                         uint32_t _flags_save_string = ndr->flags;
8081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8082                         if (r->architecture) {
8083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8085                         }
8086                         ndr->flags = _flags_save_string;
8087                 }
8088                 {
8089                         uint32_t _flags_save_string = ndr->flags;
8090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8091                         if (r->driver_path) {
8092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8094                         }
8095                         ndr->flags = _flags_save_string;
8096                 }
8097                 {
8098                         uint32_t _flags_save_string = ndr->flags;
8099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8100                         if (r->data_file) {
8101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8103                         }
8104                         ndr->flags = _flags_save_string;
8105                 }
8106                 {
8107                         uint32_t _flags_save_string = ndr->flags;
8108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8109                         if (r->config_file) {
8110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8112                         }
8113                         ndr->flags = _flags_save_string;
8114                 }
8115                 {
8116                         uint32_t _flags_save_string = ndr->flags;
8117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8118                         if (r->help_file) {
8119                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8121                         }
8122                         ndr->flags = _flags_save_string;
8123                 }
8124                 {
8125                         uint32_t _flags_save_string_array = ndr->flags;
8126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8127                         if (r->dependent_files) {
8128                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8129                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8130                         }
8131                         ndr->flags = _flags_save_string_array;
8132                 }
8133                 {
8134                         uint32_t _flags_save_string = ndr->flags;
8135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8136                         if (r->monitor_name) {
8137                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8138                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8139                         }
8140                         ndr->flags = _flags_save_string;
8141                 }
8142                 {
8143                         uint32_t _flags_save_string = ndr->flags;
8144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8145                         if (r->default_datatype) {
8146                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8148                         }
8149                         ndr->flags = _flags_save_string;
8150                 }
8151                 {
8152                         uint32_t _flags_save_string_array = ndr->flags;
8153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8154                         if (r->previous_names) {
8155                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8156                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8157                         }
8158                         ndr->flags = _flags_save_string_array;
8159                 }
8160         }
8161         return NDR_ERR_SUCCESS;
8162 }
8163
8164 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
8165 {
8166         uint32_t _ptr_driver_name;
8167         TALLOC_CTX *_mem_save_driver_name_0;
8168         uint32_t _ptr_architecture;
8169         TALLOC_CTX *_mem_save_architecture_0;
8170         uint32_t _ptr_driver_path;
8171         TALLOC_CTX *_mem_save_driver_path_0;
8172         uint32_t _ptr_data_file;
8173         TALLOC_CTX *_mem_save_data_file_0;
8174         uint32_t _ptr_config_file;
8175         TALLOC_CTX *_mem_save_config_file_0;
8176         uint32_t _ptr_help_file;
8177         TALLOC_CTX *_mem_save_help_file_0;
8178         uint32_t _ptr_dependent_files;
8179         TALLOC_CTX *_mem_save_dependent_files_0;
8180         uint32_t _ptr_monitor_name;
8181         TALLOC_CTX *_mem_save_monitor_name_0;
8182         uint32_t _ptr_default_datatype;
8183         TALLOC_CTX *_mem_save_default_datatype_0;
8184         uint32_t _ptr_previous_names;
8185         TALLOC_CTX *_mem_save_previous_names_0;
8186         if (ndr_flags & NDR_SCALARS) {
8187                 NDR_CHECK(ndr_pull_align(ndr, 4));
8188                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8189                 {
8190                         uint32_t _flags_save_string = ndr->flags;
8191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8193                         if (_ptr_driver_name) {
8194                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8196                         } else {
8197                                 r->driver_name = NULL;
8198                         }
8199                         ndr->flags = _flags_save_string;
8200                 }
8201                 {
8202                         uint32_t _flags_save_string = ndr->flags;
8203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8205                         if (_ptr_architecture) {
8206                                 NDR_PULL_ALLOC(ndr, r->architecture);
8207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8208                         } else {
8209                                 r->architecture = NULL;
8210                         }
8211                         ndr->flags = _flags_save_string;
8212                 }
8213                 {
8214                         uint32_t _flags_save_string = ndr->flags;
8215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8217                         if (_ptr_driver_path) {
8218                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8220                         } else {
8221                                 r->driver_path = NULL;
8222                         }
8223                         ndr->flags = _flags_save_string;
8224                 }
8225                 {
8226                         uint32_t _flags_save_string = ndr->flags;
8227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8229                         if (_ptr_data_file) {
8230                                 NDR_PULL_ALLOC(ndr, r->data_file);
8231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8232                         } else {
8233                                 r->data_file = NULL;
8234                         }
8235                         ndr->flags = _flags_save_string;
8236                 }
8237                 {
8238                         uint32_t _flags_save_string = ndr->flags;
8239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8241                         if (_ptr_config_file) {
8242                                 NDR_PULL_ALLOC(ndr, r->config_file);
8243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8244                         } else {
8245                                 r->config_file = NULL;
8246                         }
8247                         ndr->flags = _flags_save_string;
8248                 }
8249                 {
8250                         uint32_t _flags_save_string = ndr->flags;
8251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8253                         if (_ptr_help_file) {
8254                                 NDR_PULL_ALLOC(ndr, r->help_file);
8255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
8256                         } else {
8257                                 r->help_file = NULL;
8258                         }
8259                         ndr->flags = _flags_save_string;
8260                 }
8261                 {
8262                         uint32_t _flags_save_string_array = ndr->flags;
8263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8264                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8265                         if (_ptr_dependent_files) {
8266                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
8267                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
8268                         } else {
8269                                 r->dependent_files = NULL;
8270                         }
8271                         ndr->flags = _flags_save_string_array;
8272                 }
8273                 {
8274                         uint32_t _flags_save_string = ndr->flags;
8275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8276                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8277                         if (_ptr_monitor_name) {
8278                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
8279                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
8280                         } else {
8281                                 r->monitor_name = NULL;
8282                         }
8283                         ndr->flags = _flags_save_string;
8284                 }
8285                 {
8286                         uint32_t _flags_save_string = ndr->flags;
8287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8288                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8289                         if (_ptr_default_datatype) {
8290                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
8291                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
8292                         } else {
8293                                 r->default_datatype = NULL;
8294                         }
8295                         ndr->flags = _flags_save_string;
8296                 }
8297                 {
8298                         uint32_t _flags_save_string_array = ndr->flags;
8299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8300                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8301                         if (_ptr_previous_names) {
8302                                 NDR_PULL_ALLOC(ndr, r->previous_names);
8303                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
8304                         } else {
8305                                 r->previous_names = NULL;
8306                         }
8307                         ndr->flags = _flags_save_string_array;
8308                 }
8309         }
8310         if (ndr_flags & NDR_BUFFERS) {
8311                 {
8312                         uint32_t _flags_save_string = ndr->flags;
8313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8314                         if (r->driver_name) {
8315                                 uint32_t _relative_save_offset;
8316                                 _relative_save_offset = ndr->offset;
8317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8318                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8319                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
8330                                 uint32_t _relative_save_offset;
8331                                 _relative_save_offset = ndr->offset;
8332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8333                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8334                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_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->driver_path) {
8345                                 uint32_t _relative_save_offset;
8346                                 _relative_save_offset = ndr->offset;
8347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8348                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8349                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_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->data_file) {
8360                                 uint32_t _relative_save_offset;
8361                                 _relative_save_offset = ndr->offset;
8362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8363                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8364                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_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->config_file) {
8375                                 uint32_t _relative_save_offset;
8376                                 _relative_save_offset = ndr->offset;
8377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8378                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8379                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8382                                 ndr->offset = _relative_save_offset;
8383                         }
8384                         ndr->flags = _flags_save_string;
8385                 }
8386                 {
8387                         uint32_t _flags_save_string = ndr->flags;
8388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8389                         if (r->help_file) {
8390                                 uint32_t _relative_save_offset;
8391                                 _relative_save_offset = ndr->offset;
8392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
8393                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8394                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
8396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8397                                 ndr->offset = _relative_save_offset;
8398                         }
8399                         ndr->flags = _flags_save_string;
8400                 }
8401                 {
8402                         uint32_t _flags_save_string_array = ndr->flags;
8403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8404                         if (r->dependent_files) {
8405                                 uint32_t _relative_save_offset;
8406                                 _relative_save_offset = ndr->offset;
8407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
8408                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8409                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8410                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
8411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8412                                 ndr->offset = _relative_save_offset;
8413                         }
8414                         ndr->flags = _flags_save_string_array;
8415                 }
8416                 {
8417                         uint32_t _flags_save_string = ndr->flags;
8418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8419                         if (r->monitor_name) {
8420                                 uint32_t _relative_save_offset;
8421                                 _relative_save_offset = ndr->offset;
8422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
8423                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8424                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
8426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8427                                 ndr->offset = _relative_save_offset;
8428                         }
8429                         ndr->flags = _flags_save_string;
8430                 }
8431                 {
8432                         uint32_t _flags_save_string = ndr->flags;
8433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8434                         if (r->default_datatype) {
8435                                 uint32_t _relative_save_offset;
8436                                 _relative_save_offset = ndr->offset;
8437                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
8438                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8439                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8440                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
8441                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8442                                 ndr->offset = _relative_save_offset;
8443                         }
8444                         ndr->flags = _flags_save_string;
8445                 }
8446                 {
8447                         uint32_t _flags_save_string_array = ndr->flags;
8448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8449                         if (r->previous_names) {
8450                                 uint32_t _relative_save_offset;
8451                                 _relative_save_offset = ndr->offset;
8452                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
8453                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8454                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8455                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
8456                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8457                                 ndr->offset = _relative_save_offset;
8458                         }
8459                         ndr->flags = _flags_save_string_array;
8460                 }
8461         }
8462         return NDR_ERR_SUCCESS;
8463 }
8464
8465 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
8466 {
8467         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
8468         ndr->depth++;
8469         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8470         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8471         ndr->depth++;
8472         if (r->driver_name) {
8473                 ndr_print_string(ndr, "driver_name", r->driver_name);
8474         }
8475         ndr->depth--;
8476         ndr_print_ptr(ndr, "architecture", r->architecture);
8477         ndr->depth++;
8478         if (r->architecture) {
8479                 ndr_print_string(ndr, "architecture", r->architecture);
8480         }
8481         ndr->depth--;
8482         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8483         ndr->depth++;
8484         if (r->driver_path) {
8485                 ndr_print_string(ndr, "driver_path", r->driver_path);
8486         }
8487         ndr->depth--;
8488         ndr_print_ptr(ndr, "data_file", r->data_file);
8489         ndr->depth++;
8490         if (r->data_file) {
8491                 ndr_print_string(ndr, "data_file", r->data_file);
8492         }
8493         ndr->depth--;
8494         ndr_print_ptr(ndr, "config_file", r->config_file);
8495         ndr->depth++;
8496         if (r->config_file) {
8497                 ndr_print_string(ndr, "config_file", r->config_file);
8498         }
8499         ndr->depth--;
8500         ndr_print_ptr(ndr, "help_file", r->help_file);
8501         ndr->depth++;
8502         if (r->help_file) {
8503                 ndr_print_string(ndr, "help_file", r->help_file);
8504         }
8505         ndr->depth--;
8506         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8507         ndr->depth++;
8508         if (r->dependent_files) {
8509                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
8510         }
8511         ndr->depth--;
8512         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8513         ndr->depth++;
8514         if (r->monitor_name) {
8515                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8516         }
8517         ndr->depth--;
8518         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8519         ndr->depth++;
8520         if (r->default_datatype) {
8521                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8522         }
8523         ndr->depth--;
8524         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8525         ndr->depth++;
8526         if (r->previous_names) {
8527                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
8528         }
8529         ndr->depth--;
8530         ndr->depth--;
8531 }
8532
8533 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
8534 {
8535         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
8536 }
8537
8538 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
8539 {
8540         if (ndr_flags & NDR_SCALARS) {
8541                 NDR_CHECK(ndr_push_align(ndr, 4));
8542                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8543                 {
8544                         uint32_t _flags_save_string = ndr->flags;
8545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8546                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8547                         ndr->flags = _flags_save_string;
8548                 }
8549                 {
8550                         uint32_t _flags_save_string = ndr->flags;
8551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8552                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8553                         ndr->flags = _flags_save_string;
8554                 }
8555                 {
8556                         uint32_t _flags_save_string = ndr->flags;
8557                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8558                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8559                         ndr->flags = _flags_save_string;
8560                 }
8561                 {
8562                         uint32_t _flags_save_string = ndr->flags;
8563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8564                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8571                         ndr->flags = _flags_save_string;
8572                 }
8573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
8574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
8575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
8576         }
8577         if (ndr_flags & NDR_BUFFERS) {
8578                 {
8579                         uint32_t _flags_save_string = ndr->flags;
8580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8581                         if (r->driver_name) {
8582                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8583                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8584                         }
8585                         ndr->flags = _flags_save_string;
8586                 }
8587                 {
8588                         uint32_t _flags_save_string = ndr->flags;
8589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8590                         if (r->architecture) {
8591                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8592                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8593                         }
8594                         ndr->flags = _flags_save_string;
8595                 }
8596                 {
8597                         uint32_t _flags_save_string = ndr->flags;
8598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8599                         if (r->driver_path) {
8600                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8601                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8602                         }
8603                         ndr->flags = _flags_save_string;
8604                 }
8605                 {
8606                         uint32_t _flags_save_string = ndr->flags;
8607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8608                         if (r->data_file) {
8609                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8610                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8611                         }
8612                         ndr->flags = _flags_save_string;
8613                 }
8614                 {
8615                         uint32_t _flags_save_string = ndr->flags;
8616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8617                         if (r->config_file) {
8618                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8619                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8620                         }
8621                         ndr->flags = _flags_save_string;
8622                 }
8623         }
8624         return NDR_ERR_SUCCESS;
8625 }
8626
8627 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
8628 {
8629         uint32_t _ptr_driver_name;
8630         TALLOC_CTX *_mem_save_driver_name_0;
8631         uint32_t _ptr_architecture;
8632         TALLOC_CTX *_mem_save_architecture_0;
8633         uint32_t _ptr_driver_path;
8634         TALLOC_CTX *_mem_save_driver_path_0;
8635         uint32_t _ptr_data_file;
8636         TALLOC_CTX *_mem_save_data_file_0;
8637         uint32_t _ptr_config_file;
8638         TALLOC_CTX *_mem_save_config_file_0;
8639         if (ndr_flags & NDR_SCALARS) {
8640                 NDR_CHECK(ndr_pull_align(ndr, 4));
8641                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8642                 {
8643                         uint32_t _flags_save_string = ndr->flags;
8644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8645                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8646                         if (_ptr_driver_name) {
8647                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8648                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8649                         } else {
8650                                 r->driver_name = NULL;
8651                         }
8652                         ndr->flags = _flags_save_string;
8653                 }
8654                 {
8655                         uint32_t _flags_save_string = ndr->flags;
8656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8657                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8658                         if (_ptr_architecture) {
8659                                 NDR_PULL_ALLOC(ndr, r->architecture);
8660                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8661                         } else {
8662                                 r->architecture = NULL;
8663                         }
8664                         ndr->flags = _flags_save_string;
8665                 }
8666                 {
8667                         uint32_t _flags_save_string = ndr->flags;
8668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8669                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8670                         if (_ptr_driver_path) {
8671                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8672                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8673                         } else {
8674                                 r->driver_path = NULL;
8675                         }
8676                         ndr->flags = _flags_save_string;
8677                 }
8678                 {
8679                         uint32_t _flags_save_string = ndr->flags;
8680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8682                         if (_ptr_data_file) {
8683                                 NDR_PULL_ALLOC(ndr, r->data_file);
8684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8685                         } else {
8686                                 r->data_file = NULL;
8687                         }
8688                         ndr->flags = _flags_save_string;
8689                 }
8690                 {
8691                         uint32_t _flags_save_string = ndr->flags;
8692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8694                         if (_ptr_config_file) {
8695                                 NDR_PULL_ALLOC(ndr, r->config_file);
8696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8697                         } else {
8698                                 r->config_file = NULL;
8699                         }
8700                         ndr->flags = _flags_save_string;
8701                 }
8702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
8703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
8704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
8705         }
8706         if (ndr_flags & NDR_BUFFERS) {
8707                 {
8708                         uint32_t _flags_save_string = ndr->flags;
8709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8710                         if (r->driver_name) {
8711                                 uint32_t _relative_save_offset;
8712                                 _relative_save_offset = ndr->offset;
8713                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8714                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8716                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8717                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8718                                 ndr->offset = _relative_save_offset;
8719                         }
8720                         ndr->flags = _flags_save_string;
8721                 }
8722                 {
8723                         uint32_t _flags_save_string = ndr->flags;
8724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8725                         if (r->architecture) {
8726                                 uint32_t _relative_save_offset;
8727                                 _relative_save_offset = ndr->offset;
8728                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8729                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8730                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8731                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8732                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8733                                 ndr->offset = _relative_save_offset;
8734                         }
8735                         ndr->flags = _flags_save_string;
8736                 }
8737                 {
8738                         uint32_t _flags_save_string = ndr->flags;
8739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8740                         if (r->driver_path) {
8741                                 uint32_t _relative_save_offset;
8742                                 _relative_save_offset = ndr->offset;
8743                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8744                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8745                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8746                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8747                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8748                                 ndr->offset = _relative_save_offset;
8749                         }
8750                         ndr->flags = _flags_save_string;
8751                 }
8752                 {
8753                         uint32_t _flags_save_string = ndr->flags;
8754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8755                         if (r->data_file) {
8756                                 uint32_t _relative_save_offset;
8757                                 _relative_save_offset = ndr->offset;
8758                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8759                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8760                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8761                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8762                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8763                                 ndr->offset = _relative_save_offset;
8764                         }
8765                         ndr->flags = _flags_save_string;
8766                 }
8767                 {
8768                         uint32_t _flags_save_string = ndr->flags;
8769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8770                         if (r->config_file) {
8771                                 uint32_t _relative_save_offset;
8772                                 _relative_save_offset = ndr->offset;
8773                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8774                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8775                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8776                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8777                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8778                                 ndr->offset = _relative_save_offset;
8779                         }
8780                         ndr->flags = _flags_save_string;
8781                 }
8782         }
8783         return NDR_ERR_SUCCESS;
8784 }
8785
8786 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
8787 {
8788         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
8789         ndr->depth++;
8790         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8791         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8792         ndr->depth++;
8793         if (r->driver_name) {
8794                 ndr_print_string(ndr, "driver_name", r->driver_name);
8795         }
8796         ndr->depth--;
8797         ndr_print_ptr(ndr, "architecture", r->architecture);
8798         ndr->depth++;
8799         if (r->architecture) {
8800                 ndr_print_string(ndr, "architecture", r->architecture);
8801         }
8802         ndr->depth--;
8803         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8804         ndr->depth++;
8805         if (r->driver_path) {
8806                 ndr_print_string(ndr, "driver_path", r->driver_path);
8807         }
8808         ndr->depth--;
8809         ndr_print_ptr(ndr, "data_file", r->data_file);
8810         ndr->depth++;
8811         if (r->data_file) {
8812                 ndr_print_string(ndr, "data_file", r->data_file);
8813         }
8814         ndr->depth--;
8815         ndr_print_ptr(ndr, "config_file", r->config_file);
8816         ndr->depth++;
8817         if (r->config_file) {
8818                 ndr_print_string(ndr, "config_file", r->config_file);
8819         }
8820         ndr->depth--;
8821         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
8822         ndr_print_uint32(ndr, "config_version", r->config_version);
8823         ndr_print_uint32(ndr, "driver_version", r->driver_version);
8824         ndr->depth--;
8825 }
8826
8827 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
8828 {
8829         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
8830 }
8831
8832 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
8833 {
8834         if (ndr_flags & NDR_SCALARS) {
8835                 NDR_CHECK(ndr_push_align(ndr, 8));
8836                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8837                 {
8838                         uint32_t _flags_save_string = ndr->flags;
8839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8840                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8841                         ndr->flags = _flags_save_string;
8842                 }
8843                 {
8844                         uint32_t _flags_save_string = ndr->flags;
8845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8846                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8847                         ndr->flags = _flags_save_string;
8848                 }
8849                 {
8850                         uint32_t _flags_save_string = ndr->flags;
8851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8852                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8853                         ndr->flags = _flags_save_string;
8854                 }
8855                 {
8856                         uint32_t _flags_save_string = ndr->flags;
8857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8858                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8859                         ndr->flags = _flags_save_string;
8860                 }
8861                 {
8862                         uint32_t _flags_save_string = ndr->flags;
8863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8864                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8865                         ndr->flags = _flags_save_string;
8866                 }
8867                 {
8868                         uint32_t _flags_save_string = ndr->flags;
8869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8870                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8871                         ndr->flags = _flags_save_string;
8872                 }
8873                 {
8874                         uint32_t _flags_save_string_array = ndr->flags;
8875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8876                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8877                         ndr->flags = _flags_save_string_array;
8878                 }
8879                 {
8880                         uint32_t _flags_save_string = ndr->flags;
8881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8882                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8883                         ndr->flags = _flags_save_string;
8884                 }
8885                 {
8886                         uint32_t _flags_save_string = ndr->flags;
8887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8888                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8889                         ndr->flags = _flags_save_string;
8890                 }
8891                 {
8892                         uint32_t _flags_save_string_array = ndr->flags;
8893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8895                         ndr->flags = _flags_save_string_array;
8896                 }
8897                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8898                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8899                 {
8900                         uint32_t _flags_save_string = ndr->flags;
8901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8902                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
8903                         ndr->flags = _flags_save_string;
8904                 }
8905                 {
8906                         uint32_t _flags_save_string = ndr->flags;
8907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8908                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
8909                         ndr->flags = _flags_save_string;
8910                 }
8911                 {
8912                         uint32_t _flags_save_string = ndr->flags;
8913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8914                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
8915                         ndr->flags = _flags_save_string;
8916                 }
8917                 {
8918                         uint32_t _flags_save_string = ndr->flags;
8919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8920                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
8921                         ndr->flags = _flags_save_string;
8922                 }
8923         }
8924         if (ndr_flags & NDR_BUFFERS) {
8925                 {
8926                         uint32_t _flags_save_string = ndr->flags;
8927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8928                         if (r->driver_name) {
8929                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8930                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8931                         }
8932                         ndr->flags = _flags_save_string;
8933                 }
8934                 {
8935                         uint32_t _flags_save_string = ndr->flags;
8936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8937                         if (r->architecture) {
8938                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8939                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8940                         }
8941                         ndr->flags = _flags_save_string;
8942                 }
8943                 {
8944                         uint32_t _flags_save_string = ndr->flags;
8945                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8946                         if (r->driver_path) {
8947                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8948                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8949                         }
8950                         ndr->flags = _flags_save_string;
8951                 }
8952                 {
8953                         uint32_t _flags_save_string = ndr->flags;
8954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8955                         if (r->data_file) {
8956                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8957                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8958                         }
8959                         ndr->flags = _flags_save_string;
8960                 }
8961                 {
8962                         uint32_t _flags_save_string = ndr->flags;
8963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8964                         if (r->config_file) {
8965                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8966                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8967                         }
8968                         ndr->flags = _flags_save_string;
8969                 }
8970                 {
8971                         uint32_t _flags_save_string = ndr->flags;
8972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8973                         if (r->help_file) {
8974                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8975                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8976                         }
8977                         ndr->flags = _flags_save_string;
8978                 }
8979                 {
8980                         uint32_t _flags_save_string_array = ndr->flags;
8981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8982                         if (r->dependent_files) {
8983                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8984                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8985                         }
8986                         ndr->flags = _flags_save_string_array;
8987                 }
8988                 {
8989                         uint32_t _flags_save_string = ndr->flags;
8990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8991                         if (r->monitor_name) {
8992                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8993                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8994                         }
8995                         ndr->flags = _flags_save_string;
8996                 }
8997                 {
8998                         uint32_t _flags_save_string = ndr->flags;
8999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9000                         if (r->default_datatype) {
9001                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9002                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9003                         }
9004                         ndr->flags = _flags_save_string;
9005                 }
9006                 {
9007                         uint32_t _flags_save_string_array = ndr->flags;
9008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9009                         if (r->previous_names) {
9010                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9011                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9012                         }
9013                         ndr->flags = _flags_save_string_array;
9014                 }
9015                 {
9016                         uint32_t _flags_save_string = ndr->flags;
9017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9018                         if (r->manufacturer_name) {
9019                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9020                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9021                         }
9022                         ndr->flags = _flags_save_string;
9023                 }
9024                 {
9025                         uint32_t _flags_save_string = ndr->flags;
9026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9027                         if (r->manufacturer_url) {
9028                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9029                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9030                         }
9031                         ndr->flags = _flags_save_string;
9032                 }
9033                 {
9034                         uint32_t _flags_save_string = ndr->flags;
9035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9036                         if (r->hardware_id) {
9037                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9038                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9039                         }
9040                         ndr->flags = _flags_save_string;
9041                 }
9042                 {
9043                         uint32_t _flags_save_string = ndr->flags;
9044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9045                         if (r->provider) {
9046                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9047                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9048                         }
9049                         ndr->flags = _flags_save_string;
9050                 }
9051         }
9052         return NDR_ERR_SUCCESS;
9053 }
9054
9055 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
9056 {
9057         uint32_t _ptr_driver_name;
9058         TALLOC_CTX *_mem_save_driver_name_0;
9059         uint32_t _ptr_architecture;
9060         TALLOC_CTX *_mem_save_architecture_0;
9061         uint32_t _ptr_driver_path;
9062         TALLOC_CTX *_mem_save_driver_path_0;
9063         uint32_t _ptr_data_file;
9064         TALLOC_CTX *_mem_save_data_file_0;
9065         uint32_t _ptr_config_file;
9066         TALLOC_CTX *_mem_save_config_file_0;
9067         uint32_t _ptr_help_file;
9068         TALLOC_CTX *_mem_save_help_file_0;
9069         uint32_t _ptr_dependent_files;
9070         TALLOC_CTX *_mem_save_dependent_files_0;
9071         uint32_t _ptr_monitor_name;
9072         TALLOC_CTX *_mem_save_monitor_name_0;
9073         uint32_t _ptr_default_datatype;
9074         TALLOC_CTX *_mem_save_default_datatype_0;
9075         uint32_t _ptr_previous_names;
9076         TALLOC_CTX *_mem_save_previous_names_0;
9077         uint32_t _ptr_manufacturer_name;
9078         TALLOC_CTX *_mem_save_manufacturer_name_0;
9079         uint32_t _ptr_manufacturer_url;
9080         TALLOC_CTX *_mem_save_manufacturer_url_0;
9081         uint32_t _ptr_hardware_id;
9082         TALLOC_CTX *_mem_save_hardware_id_0;
9083         uint32_t _ptr_provider;
9084         TALLOC_CTX *_mem_save_provider_0;
9085         if (ndr_flags & NDR_SCALARS) {
9086                 NDR_CHECK(ndr_pull_align(ndr, 8));
9087                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9088                 {
9089                         uint32_t _flags_save_string = ndr->flags;
9090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9091                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9092                         if (_ptr_driver_name) {
9093                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9094                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9095                         } else {
9096                                 r->driver_name = NULL;
9097                         }
9098                         ndr->flags = _flags_save_string;
9099                 }
9100                 {
9101                         uint32_t _flags_save_string = ndr->flags;
9102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9103                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9104                         if (_ptr_architecture) {
9105                                 NDR_PULL_ALLOC(ndr, r->architecture);
9106                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9107                         } else {
9108                                 r->architecture = NULL;
9109                         }
9110                         ndr->flags = _flags_save_string;
9111                 }
9112                 {
9113                         uint32_t _flags_save_string = ndr->flags;
9114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9115                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9116                         if (_ptr_driver_path) {
9117                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9118                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9119                         } else {
9120                                 r->driver_path = NULL;
9121                         }
9122                         ndr->flags = _flags_save_string;
9123                 }
9124                 {
9125                         uint32_t _flags_save_string = ndr->flags;
9126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9127                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9128                         if (_ptr_data_file) {
9129                                 NDR_PULL_ALLOC(ndr, r->data_file);
9130                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9131                         } else {
9132                                 r->data_file = NULL;
9133                         }
9134                         ndr->flags = _flags_save_string;
9135                 }
9136                 {
9137                         uint32_t _flags_save_string = ndr->flags;
9138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9139                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9140                         if (_ptr_config_file) {
9141                                 NDR_PULL_ALLOC(ndr, r->config_file);
9142                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9143                         } else {
9144                                 r->config_file = NULL;
9145                         }
9146                         ndr->flags = _flags_save_string;
9147                 }
9148                 {
9149                         uint32_t _flags_save_string = ndr->flags;
9150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9151                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9152                         if (_ptr_help_file) {
9153                                 NDR_PULL_ALLOC(ndr, r->help_file);
9154                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9155                         } else {
9156                                 r->help_file = NULL;
9157                         }
9158                         ndr->flags = _flags_save_string;
9159                 }
9160                 {
9161                         uint32_t _flags_save_string_array = ndr->flags;
9162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9163                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9164                         if (_ptr_dependent_files) {
9165                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9166                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9167                         } else {
9168                                 r->dependent_files = NULL;
9169                         }
9170                         ndr->flags = _flags_save_string_array;
9171                 }
9172                 {
9173                         uint32_t _flags_save_string = ndr->flags;
9174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9175                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9176                         if (_ptr_monitor_name) {
9177                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9178                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9179                         } else {
9180                                 r->monitor_name = NULL;
9181                         }
9182                         ndr->flags = _flags_save_string;
9183                 }
9184                 {
9185                         uint32_t _flags_save_string = ndr->flags;
9186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9187                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9188                         if (_ptr_default_datatype) {
9189                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9190                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9191                         } else {
9192                                 r->default_datatype = NULL;
9193                         }
9194                         ndr->flags = _flags_save_string;
9195                 }
9196                 {
9197                         uint32_t _flags_save_string_array = ndr->flags;
9198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9199                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9200                         if (_ptr_previous_names) {
9201                                 NDR_PULL_ALLOC(ndr, r->previous_names);
9202                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
9203                         } else {
9204                                 r->previous_names = NULL;
9205                         }
9206                         ndr->flags = _flags_save_string_array;
9207                 }
9208                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9209                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9210                 {
9211                         uint32_t _flags_save_string = ndr->flags;
9212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9213                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9214                         if (_ptr_manufacturer_name) {
9215                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9216                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
9217                         } else {
9218                                 r->manufacturer_name = NULL;
9219                         }
9220                         ndr->flags = _flags_save_string;
9221                 }
9222                 {
9223                         uint32_t _flags_save_string = ndr->flags;
9224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9225                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9226                         if (_ptr_manufacturer_url) {
9227                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9228                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
9229                         } else {
9230                                 r->manufacturer_url = NULL;
9231                         }
9232                         ndr->flags = _flags_save_string;
9233                 }
9234                 {
9235                         uint32_t _flags_save_string = ndr->flags;
9236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9237                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9238                         if (_ptr_hardware_id) {
9239                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
9240                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
9241                         } else {
9242                                 r->hardware_id = NULL;
9243                         }
9244                         ndr->flags = _flags_save_string;
9245                 }
9246                 {
9247                         uint32_t _flags_save_string = ndr->flags;
9248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9249                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9250                         if (_ptr_provider) {
9251                                 NDR_PULL_ALLOC(ndr, r->provider);
9252                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
9253                         } else {
9254                                 r->provider = NULL;
9255                         }
9256                         ndr->flags = _flags_save_string;
9257                 }
9258         }
9259         if (ndr_flags & NDR_BUFFERS) {
9260                 {
9261                         uint32_t _flags_save_string = ndr->flags;
9262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9263                         if (r->driver_name) {
9264                                 uint32_t _relative_save_offset;
9265                                 _relative_save_offset = ndr->offset;
9266                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9267                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9268                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9269                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9270                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9271                                 ndr->offset = _relative_save_offset;
9272                         }
9273                         ndr->flags = _flags_save_string;
9274                 }
9275                 {
9276                         uint32_t _flags_save_string = ndr->flags;
9277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9278                         if (r->architecture) {
9279                                 uint32_t _relative_save_offset;
9280                                 _relative_save_offset = ndr->offset;
9281                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9282                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9283                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9284                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9285                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9286                                 ndr->offset = _relative_save_offset;
9287                         }
9288                         ndr->flags = _flags_save_string;
9289                 }
9290                 {
9291                         uint32_t _flags_save_string = ndr->flags;
9292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9293                         if (r->driver_path) {
9294                                 uint32_t _relative_save_offset;
9295                                 _relative_save_offset = ndr->offset;
9296                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9297                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9298                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9299                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9300                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9301                                 ndr->offset = _relative_save_offset;
9302                         }
9303                         ndr->flags = _flags_save_string;
9304                 }
9305                 {
9306                         uint32_t _flags_save_string = ndr->flags;
9307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9308                         if (r->data_file) {
9309                                 uint32_t _relative_save_offset;
9310                                 _relative_save_offset = ndr->offset;
9311                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9312                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9313                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9314                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9315                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9316                                 ndr->offset = _relative_save_offset;
9317                         }
9318                         ndr->flags = _flags_save_string;
9319                 }
9320                 {
9321                         uint32_t _flags_save_string = ndr->flags;
9322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9323                         if (r->config_file) {
9324                                 uint32_t _relative_save_offset;
9325                                 _relative_save_offset = ndr->offset;
9326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9327                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9328                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9331                                 ndr->offset = _relative_save_offset;
9332                         }
9333                         ndr->flags = _flags_save_string;
9334                 }
9335                 {
9336                         uint32_t _flags_save_string = ndr->flags;
9337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9338                         if (r->help_file) {
9339                                 uint32_t _relative_save_offset;
9340                                 _relative_save_offset = ndr->offset;
9341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9342                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9343                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9346                                 ndr->offset = _relative_save_offset;
9347                         }
9348                         ndr->flags = _flags_save_string;
9349                 }
9350                 {
9351                         uint32_t _flags_save_string_array = ndr->flags;
9352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9353                         if (r->dependent_files) {
9354                                 uint32_t _relative_save_offset;
9355                                 _relative_save_offset = ndr->offset;
9356                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9357                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9358                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9359                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9360                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9361                                 ndr->offset = _relative_save_offset;
9362                         }
9363                         ndr->flags = _flags_save_string_array;
9364                 }
9365                 {
9366                         uint32_t _flags_save_string = ndr->flags;
9367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9368                         if (r->monitor_name) {
9369                                 uint32_t _relative_save_offset;
9370                                 _relative_save_offset = ndr->offset;
9371                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9372                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9373                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9374                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9375                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9376                                 ndr->offset = _relative_save_offset;
9377                         }
9378                         ndr->flags = _flags_save_string;
9379                 }
9380                 {
9381                         uint32_t _flags_save_string = ndr->flags;
9382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9383                         if (r->default_datatype) {
9384                                 uint32_t _relative_save_offset;
9385                                 _relative_save_offset = ndr->offset;
9386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9387                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9388                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9389                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9391                                 ndr->offset = _relative_save_offset;
9392                         }
9393                         ndr->flags = _flags_save_string;
9394                 }
9395                 {
9396                         uint32_t _flags_save_string_array = ndr->flags;
9397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9398                         if (r->previous_names) {
9399                                 uint32_t _relative_save_offset;
9400                                 _relative_save_offset = ndr->offset;
9401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
9402                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9403                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9404                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
9405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9406                                 ndr->offset = _relative_save_offset;
9407                         }
9408                         ndr->flags = _flags_save_string_array;
9409                 }
9410                 {
9411                         uint32_t _flags_save_string = ndr->flags;
9412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9413                         if (r->manufacturer_name) {
9414                                 uint32_t _relative_save_offset;
9415                                 _relative_save_offset = ndr->offset;
9416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
9417                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9418                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
9420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9421                                 ndr->offset = _relative_save_offset;
9422                         }
9423                         ndr->flags = _flags_save_string;
9424                 }
9425                 {
9426                         uint32_t _flags_save_string = ndr->flags;
9427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9428                         if (r->manufacturer_url) {
9429                                 uint32_t _relative_save_offset;
9430                                 _relative_save_offset = ndr->offset;
9431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
9432                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9433                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9434                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
9435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9436                                 ndr->offset = _relative_save_offset;
9437                         }
9438                         ndr->flags = _flags_save_string;
9439                 }
9440                 {
9441                         uint32_t _flags_save_string = ndr->flags;
9442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9443                         if (r->hardware_id) {
9444                                 uint32_t _relative_save_offset;
9445                                 _relative_save_offset = ndr->offset;
9446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
9447                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9448                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
9450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9451                                 ndr->offset = _relative_save_offset;
9452                         }
9453                         ndr->flags = _flags_save_string;
9454                 }
9455                 {
9456                         uint32_t _flags_save_string = ndr->flags;
9457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9458                         if (r->provider) {
9459                                 uint32_t _relative_save_offset;
9460                                 _relative_save_offset = ndr->offset;
9461                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
9462                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9463                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9464                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
9465                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9466                                 ndr->offset = _relative_save_offset;
9467                         }
9468                         ndr->flags = _flags_save_string;
9469                 }
9470         }
9471         return NDR_ERR_SUCCESS;
9472 }
9473
9474 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
9475 {
9476         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
9477         ndr->depth++;
9478         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9479         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9480         ndr->depth++;
9481         if (r->driver_name) {
9482                 ndr_print_string(ndr, "driver_name", r->driver_name);
9483         }
9484         ndr->depth--;
9485         ndr_print_ptr(ndr, "architecture", r->architecture);
9486         ndr->depth++;
9487         if (r->architecture) {
9488                 ndr_print_string(ndr, "architecture", r->architecture);
9489         }
9490         ndr->depth--;
9491         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9492         ndr->depth++;
9493         if (r->driver_path) {
9494                 ndr_print_string(ndr, "driver_path", r->driver_path);
9495         }
9496         ndr->depth--;
9497         ndr_print_ptr(ndr, "data_file", r->data_file);
9498         ndr->depth++;
9499         if (r->data_file) {
9500                 ndr_print_string(ndr, "data_file", r->data_file);
9501         }
9502         ndr->depth--;
9503         ndr_print_ptr(ndr, "config_file", r->config_file);
9504         ndr->depth++;
9505         if (r->config_file) {
9506                 ndr_print_string(ndr, "config_file", r->config_file);
9507         }
9508         ndr->depth--;
9509         ndr_print_ptr(ndr, "help_file", r->help_file);
9510         ndr->depth++;
9511         if (r->help_file) {
9512                 ndr_print_string(ndr, "help_file", r->help_file);
9513         }
9514         ndr->depth--;
9515         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9516         ndr->depth++;
9517         if (r->dependent_files) {
9518                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9519         }
9520         ndr->depth--;
9521         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9522         ndr->depth++;
9523         if (r->monitor_name) {
9524                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9525         }
9526         ndr->depth--;
9527         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9528         ndr->depth++;
9529         if (r->default_datatype) {
9530                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9531         }
9532         ndr->depth--;
9533         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9534         ndr->depth++;
9535         if (r->previous_names) {
9536                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
9537         }
9538         ndr->depth--;
9539         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9540         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9541         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9542         ndr->depth++;
9543         if (r->manufacturer_name) {
9544                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9545         }
9546         ndr->depth--;
9547         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9548         ndr->depth++;
9549         if (r->manufacturer_url) {
9550                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9551         }
9552         ndr->depth--;
9553         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9554         ndr->depth++;
9555         if (r->hardware_id) {
9556                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9557         }
9558         ndr->depth--;
9559         ndr_print_ptr(ndr, "provider", r->provider);
9560         ndr->depth++;
9561         if (r->provider) {
9562                 ndr_print_string(ndr, "provider", r->provider);
9563         }
9564         ndr->depth--;
9565         ndr->depth--;
9566 }
9567
9568 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
9569 {
9570         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
9571 }
9572
9573 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
9574 {
9575         if (ndr_flags & NDR_SCALARS) {
9576                 NDR_CHECK(ndr_push_align(ndr, 8));
9577                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
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->driver_name));
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->architecture));
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->driver_path));
9594                         ndr->flags = _flags_save_string;
9595                 }
9596                 {
9597                         uint32_t _flags_save_string = ndr->flags;
9598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9600                         ndr->flags = _flags_save_string;
9601                 }
9602                 {
9603                         uint32_t _flags_save_string = ndr->flags;
9604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9606                         ndr->flags = _flags_save_string;
9607                 }
9608                 {
9609                         uint32_t _flags_save_string = ndr->flags;
9610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9611                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
9612                         ndr->flags = _flags_save_string;
9613                 }
9614                 {
9615                         uint32_t _flags_save_string = ndr->flags;
9616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9617                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
9618                         ndr->flags = _flags_save_string;
9619                 }
9620                 {
9621                         uint32_t _flags_save_string = ndr->flags;
9622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9623                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
9624                         ndr->flags = _flags_save_string;
9625                 }
9626                 {
9627                         uint32_t _flags_save_string_array = ndr->flags;
9628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9629                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
9630                         ndr->flags = _flags_save_string_array;
9631                 }
9632                 {
9633                         uint32_t _flags_save_string_array = ndr->flags;
9634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9635                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
9636                         ndr->flags = _flags_save_string_array;
9637                 }
9638                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9639                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
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->manufacturer_name));
9644                         ndr->flags = _flags_save_string;
9645                 }
9646                 {
9647                         uint32_t _flags_save_string = ndr->flags;
9648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9649                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
9650                         ndr->flags = _flags_save_string;
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->hardware_id));
9656                         ndr->flags = _flags_save_string;
9657                 }
9658                 {
9659                         uint32_t _flags_save_string = ndr->flags;
9660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9661                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
9662                         ndr->flags = _flags_save_string;
9663                 }
9664                 {
9665                         uint32_t _flags_save_string = ndr->flags;
9666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9667                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
9668                         ndr->flags = _flags_save_string;
9669                 }
9670                 {
9671                         uint32_t _flags_save_string = ndr->flags;
9672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9673                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
9674                         ndr->flags = _flags_save_string;
9675                 }
9676                 {
9677                         uint32_t _flags_save_string_array = ndr->flags;
9678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9679                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
9680                         ndr->flags = _flags_save_string_array;
9681                 }
9682                 {
9683                         uint32_t _flags_save_string = ndr->flags;
9684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9685                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
9686                         ndr->flags = _flags_save_string;
9687                 }
9688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9689                 {
9690                         uint32_t _flags_save_string_array = ndr->flags;
9691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9692                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
9693                         ndr->flags = _flags_save_string_array;
9694                 }
9695                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9696                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9697         }
9698         if (ndr_flags & NDR_BUFFERS) {
9699                 {
9700                         uint32_t _flags_save_string = ndr->flags;
9701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9702                         if (r->driver_name) {
9703                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9704                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9705                         }
9706                         ndr->flags = _flags_save_string;
9707                 }
9708                 {
9709                         uint32_t _flags_save_string = ndr->flags;
9710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9711                         if (r->architecture) {
9712                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9713                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9714                         }
9715                         ndr->flags = _flags_save_string;
9716                 }
9717                 {
9718                         uint32_t _flags_save_string = ndr->flags;
9719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9720                         if (r->driver_path) {
9721                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9722                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9723                         }
9724                         ndr->flags = _flags_save_string;
9725                 }
9726                 {
9727                         uint32_t _flags_save_string = ndr->flags;
9728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9729                         if (r->data_file) {
9730                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9731                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9732                         }
9733                         ndr->flags = _flags_save_string;
9734                 }
9735                 {
9736                         uint32_t _flags_save_string = ndr->flags;
9737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9738                         if (r->config_file) {
9739                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9740                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9741                         }
9742                         ndr->flags = _flags_save_string;
9743                 }
9744                 {
9745                         uint32_t _flags_save_string = ndr->flags;
9746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9747                         if (r->help_file) {
9748                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
9749                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
9750                         }
9751                         ndr->flags = _flags_save_string;
9752                 }
9753                 {
9754                         uint32_t _flags_save_string = ndr->flags;
9755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9756                         if (r->monitor_name) {
9757                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
9758                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
9759                         }
9760                         ndr->flags = _flags_save_string;
9761                 }
9762                 {
9763                         uint32_t _flags_save_string = ndr->flags;
9764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9765                         if (r->default_datatype) {
9766                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9767                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9768                         }
9769                         ndr->flags = _flags_save_string;
9770                 }
9771                 {
9772                         uint32_t _flags_save_string_array = ndr->flags;
9773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9774                         if (r->dependent_files) {
9775                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
9776                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
9777                         }
9778                         ndr->flags = _flags_save_string_array;
9779                 }
9780                 {
9781                         uint32_t _flags_save_string_array = ndr->flags;
9782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9783                         if (r->previous_names) {
9784                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9785                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9786                         }
9787                         ndr->flags = _flags_save_string_array;
9788                 }
9789                 {
9790                         uint32_t _flags_save_string = ndr->flags;
9791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9792                         if (r->manufacturer_name) {
9793                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9794                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9795                         }
9796                         ndr->flags = _flags_save_string;
9797                 }
9798                 {
9799                         uint32_t _flags_save_string = ndr->flags;
9800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9801                         if (r->manufacturer_url) {
9802                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9803                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9804                         }
9805                         ndr->flags = _flags_save_string;
9806                 }
9807                 {
9808                         uint32_t _flags_save_string = ndr->flags;
9809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9810                         if (r->hardware_id) {
9811                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9812                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9813                         }
9814                         ndr->flags = _flags_save_string;
9815                 }
9816                 {
9817                         uint32_t _flags_save_string = ndr->flags;
9818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9819                         if (r->provider) {
9820                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9821                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9822                         }
9823                         ndr->flags = _flags_save_string;
9824                 }
9825                 {
9826                         uint32_t _flags_save_string = ndr->flags;
9827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9828                         if (r->print_processor) {
9829                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
9830                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
9831                         }
9832                         ndr->flags = _flags_save_string;
9833                 }
9834                 {
9835                         uint32_t _flags_save_string = ndr->flags;
9836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9837                         if (r->vendor_setup) {
9838                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
9839                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
9840                         }
9841                         ndr->flags = _flags_save_string;
9842                 }
9843                 {
9844                         uint32_t _flags_save_string_array = ndr->flags;
9845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9846                         if (r->color_profiles) {
9847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
9848                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
9849                         }
9850                         ndr->flags = _flags_save_string_array;
9851                 }
9852                 {
9853                         uint32_t _flags_save_string = ndr->flags;
9854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9855                         if (r->inf_path) {
9856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
9857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
9858                         }
9859                         ndr->flags = _flags_save_string;
9860                 }
9861                 {
9862                         uint32_t _flags_save_string_array = ndr->flags;
9863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9864                         if (r->core_driver_dependencies) {
9865                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
9866                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
9867                         }
9868                         ndr->flags = _flags_save_string_array;
9869                 }
9870         }
9871         return NDR_ERR_SUCCESS;
9872 }
9873
9874 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
9875 {
9876         uint32_t _ptr_driver_name;
9877         TALLOC_CTX *_mem_save_driver_name_0;
9878         uint32_t _ptr_architecture;
9879         TALLOC_CTX *_mem_save_architecture_0;
9880         uint32_t _ptr_driver_path;
9881         TALLOC_CTX *_mem_save_driver_path_0;
9882         uint32_t _ptr_data_file;
9883         TALLOC_CTX *_mem_save_data_file_0;
9884         uint32_t _ptr_config_file;
9885         TALLOC_CTX *_mem_save_config_file_0;
9886         uint32_t _ptr_help_file;
9887         TALLOC_CTX *_mem_save_help_file_0;
9888         uint32_t _ptr_monitor_name;
9889         TALLOC_CTX *_mem_save_monitor_name_0;
9890         uint32_t _ptr_default_datatype;
9891         TALLOC_CTX *_mem_save_default_datatype_0;
9892         uint32_t _ptr_dependent_files;
9893         TALLOC_CTX *_mem_save_dependent_files_0;
9894         uint32_t _ptr_previous_names;
9895         TALLOC_CTX *_mem_save_previous_names_0;
9896         uint32_t _ptr_manufacturer_name;
9897         TALLOC_CTX *_mem_save_manufacturer_name_0;
9898         uint32_t _ptr_manufacturer_url;
9899         TALLOC_CTX *_mem_save_manufacturer_url_0;
9900         uint32_t _ptr_hardware_id;
9901         TALLOC_CTX *_mem_save_hardware_id_0;
9902         uint32_t _ptr_provider;
9903         TALLOC_CTX *_mem_save_provider_0;
9904         uint32_t _ptr_print_processor;
9905         TALLOC_CTX *_mem_save_print_processor_0;
9906         uint32_t _ptr_vendor_setup;
9907         TALLOC_CTX *_mem_save_vendor_setup_0;
9908         uint32_t _ptr_color_profiles;
9909         TALLOC_CTX *_mem_save_color_profiles_0;
9910         uint32_t _ptr_inf_path;
9911         TALLOC_CTX *_mem_save_inf_path_0;
9912         uint32_t _ptr_core_driver_dependencies;
9913         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9914         if (ndr_flags & NDR_SCALARS) {
9915                 NDR_CHECK(ndr_pull_align(ndr, 8));
9916                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9917                 {
9918                         uint32_t _flags_save_string = ndr->flags;
9919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9920                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9921                         if (_ptr_driver_name) {
9922                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9923                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9924                         } else {
9925                                 r->driver_name = NULL;
9926                         }
9927                         ndr->flags = _flags_save_string;
9928                 }
9929                 {
9930                         uint32_t _flags_save_string = ndr->flags;
9931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9932                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9933                         if (_ptr_architecture) {
9934                                 NDR_PULL_ALLOC(ndr, r->architecture);
9935                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9936                         } else {
9937                                 r->architecture = NULL;
9938                         }
9939                         ndr->flags = _flags_save_string;
9940                 }
9941                 {
9942                         uint32_t _flags_save_string = ndr->flags;
9943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9944                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9945                         if (_ptr_driver_path) {
9946                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9947                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9948                         } else {
9949                                 r->driver_path = NULL;
9950                         }
9951                         ndr->flags = _flags_save_string;
9952                 }
9953                 {
9954                         uint32_t _flags_save_string = ndr->flags;
9955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9956                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9957                         if (_ptr_data_file) {
9958                                 NDR_PULL_ALLOC(ndr, r->data_file);
9959                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9960                         } else {
9961                                 r->data_file = NULL;
9962                         }
9963                         ndr->flags = _flags_save_string;
9964                 }
9965                 {
9966                         uint32_t _flags_save_string = ndr->flags;
9967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9968                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9969                         if (_ptr_config_file) {
9970                                 NDR_PULL_ALLOC(ndr, r->config_file);
9971                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9972                         } else {
9973                                 r->config_file = NULL;
9974                         }
9975                         ndr->flags = _flags_save_string;
9976                 }
9977                 {
9978                         uint32_t _flags_save_string = ndr->flags;
9979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9980                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9981                         if (_ptr_help_file) {
9982                                 NDR_PULL_ALLOC(ndr, r->help_file);
9983                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9984                         } else {
9985                                 r->help_file = NULL;
9986                         }
9987                         ndr->flags = _flags_save_string;
9988                 }
9989                 {
9990                         uint32_t _flags_save_string = ndr->flags;
9991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9992                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9993                         if (_ptr_monitor_name) {
9994                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9995                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9996                         } else {
9997                                 r->monitor_name = NULL;
9998                         }
9999                         ndr->flags = _flags_save_string;
10000                 }
10001                 {
10002                         uint32_t _flags_save_string = ndr->flags;
10003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10004                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10005                         if (_ptr_default_datatype) {
10006                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10007                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10008                         } else {
10009                                 r->default_datatype = NULL;
10010                         }
10011                         ndr->flags = _flags_save_string;
10012                 }
10013                 {
10014                         uint32_t _flags_save_string_array = ndr->flags;
10015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10016                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10017                         if (_ptr_dependent_files) {
10018                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10019                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10020                         } else {
10021                                 r->dependent_files = NULL;
10022                         }
10023                         ndr->flags = _flags_save_string_array;
10024                 }
10025                 {
10026                         uint32_t _flags_save_string_array = ndr->flags;
10027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10028                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10029                         if (_ptr_previous_names) {
10030                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10031                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10032                         } else {
10033                                 r->previous_names = NULL;
10034                         }
10035                         ndr->flags = _flags_save_string_array;
10036                 }
10037                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
10038                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10039                 {
10040                         uint32_t _flags_save_string = ndr->flags;
10041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10042                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10043                         if (_ptr_manufacturer_name) {
10044                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10045                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
10046                         } else {
10047                                 r->manufacturer_name = NULL;
10048                         }
10049                         ndr->flags = _flags_save_string;
10050                 }
10051                 {
10052                         uint32_t _flags_save_string = ndr->flags;
10053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10054                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10055                         if (_ptr_manufacturer_url) {
10056                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10057                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
10058                         } else {
10059                                 r->manufacturer_url = NULL;
10060                         }
10061                         ndr->flags = _flags_save_string;
10062                 }
10063                 {
10064                         uint32_t _flags_save_string = ndr->flags;
10065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10066                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10067                         if (_ptr_hardware_id) {
10068                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
10069                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
10070                         } else {
10071                                 r->hardware_id = NULL;
10072                         }
10073                         ndr->flags = _flags_save_string;
10074                 }
10075                 {
10076                         uint32_t _flags_save_string = ndr->flags;
10077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10078                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10079                         if (_ptr_provider) {
10080                                 NDR_PULL_ALLOC(ndr, r->provider);
10081                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
10082                         } else {
10083                                 r->provider = NULL;
10084                         }
10085                         ndr->flags = _flags_save_string;
10086                 }
10087                 {
10088                         uint32_t _flags_save_string = ndr->flags;
10089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10090                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10091                         if (_ptr_print_processor) {
10092                                 NDR_PULL_ALLOC(ndr, r->print_processor);
10093                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
10094                         } else {
10095                                 r->print_processor = NULL;
10096                         }
10097                         ndr->flags = _flags_save_string;
10098                 }
10099                 {
10100                         uint32_t _flags_save_string = ndr->flags;
10101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10102                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10103                         if (_ptr_vendor_setup) {
10104                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
10105                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
10106                         } else {
10107                                 r->vendor_setup = NULL;
10108                         }
10109                         ndr->flags = _flags_save_string;
10110                 }
10111                 {
10112                         uint32_t _flags_save_string_array = ndr->flags;
10113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10114                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10115                         if (_ptr_color_profiles) {
10116                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
10117                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
10118                         } else {
10119                                 r->color_profiles = NULL;
10120                         }
10121                         ndr->flags = _flags_save_string_array;
10122                 }
10123                 {
10124                         uint32_t _flags_save_string = ndr->flags;
10125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10126                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10127                         if (_ptr_inf_path) {
10128                                 NDR_PULL_ALLOC(ndr, r->inf_path);
10129                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
10130                         } else {
10131                                 r->inf_path = NULL;
10132                         }
10133                         ndr->flags = _flags_save_string;
10134                 }
10135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10136                 {
10137                         uint32_t _flags_save_string_array = ndr->flags;
10138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10139                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10140                         if (_ptr_core_driver_dependencies) {
10141                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10142                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
10143                         } else {
10144                                 r->core_driver_dependencies = NULL;
10145                         }
10146                         ndr->flags = _flags_save_string_array;
10147                 }
10148                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10149                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10150         }
10151         if (ndr_flags & NDR_BUFFERS) {
10152                 {
10153                         uint32_t _flags_save_string = ndr->flags;
10154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10155                         if (r->driver_name) {
10156                                 uint32_t _relative_save_offset;
10157                                 _relative_save_offset = ndr->offset;
10158                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10159                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10160                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10161                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10162                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
10171                                 uint32_t _relative_save_offset;
10172                                 _relative_save_offset = ndr->offset;
10173                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10174                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10175                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10176                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10177                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_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->driver_path) {
10186                                 uint32_t _relative_save_offset;
10187                                 _relative_save_offset = ndr->offset;
10188                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10189                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10190                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10191                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10192                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_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->data_file) {
10201                                 uint32_t _relative_save_offset;
10202                                 _relative_save_offset = ndr->offset;
10203                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10204                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10205                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10206                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10207                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_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->config_file) {
10216                                 uint32_t _relative_save_offset;
10217                                 _relative_save_offset = ndr->offset;
10218                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10219                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10220                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10221                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10222                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_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->help_file) {
10231                                 uint32_t _relative_save_offset;
10232                                 _relative_save_offset = ndr->offset;
10233                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10234                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10235                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10236                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10237                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10238                                 ndr->offset = _relative_save_offset;
10239                         }
10240                         ndr->flags = _flags_save_string;
10241                 }
10242                 {
10243                         uint32_t _flags_save_string = ndr->flags;
10244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10245                         if (r->monitor_name) {
10246                                 uint32_t _relative_save_offset;
10247                                 _relative_save_offset = ndr->offset;
10248                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10249                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10250                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10251                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10252                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10253                                 ndr->offset = _relative_save_offset;
10254                         }
10255                         ndr->flags = _flags_save_string;
10256                 }
10257                 {
10258                         uint32_t _flags_save_string = ndr->flags;
10259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10260                         if (r->default_datatype) {
10261                                 uint32_t _relative_save_offset;
10262                                 _relative_save_offset = ndr->offset;
10263                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10264                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10265                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10266                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10267                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10268                                 ndr->offset = _relative_save_offset;
10269                         }
10270                         ndr->flags = _flags_save_string;
10271                 }
10272                 {
10273                         uint32_t _flags_save_string_array = ndr->flags;
10274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10275                         if (r->dependent_files) {
10276                                 uint32_t _relative_save_offset;
10277                                 _relative_save_offset = ndr->offset;
10278                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10279                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10280                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10281                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10282                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10283                                 ndr->offset = _relative_save_offset;
10284                         }
10285                         ndr->flags = _flags_save_string_array;
10286                 }
10287                 {
10288                         uint32_t _flags_save_string_array = ndr->flags;
10289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10290                         if (r->previous_names) {
10291                                 uint32_t _relative_save_offset;
10292                                 _relative_save_offset = ndr->offset;
10293                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
10294                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10295                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10296                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
10297                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10298                                 ndr->offset = _relative_save_offset;
10299                         }
10300                         ndr->flags = _flags_save_string_array;
10301                 }
10302                 {
10303                         uint32_t _flags_save_string = ndr->flags;
10304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10305                         if (r->manufacturer_name) {
10306                                 uint32_t _relative_save_offset;
10307                                 _relative_save_offset = ndr->offset;
10308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
10309                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10310                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
10312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_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->manufacturer_url) {
10321                                 uint32_t _relative_save_offset;
10322                                 _relative_save_offset = ndr->offset;
10323                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
10324                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10325                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10326                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
10327                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_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->hardware_id) {
10336                                 uint32_t _relative_save_offset;
10337                                 _relative_save_offset = ndr->offset;
10338                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
10339                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10340                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10341                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
10342                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_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->provider) {
10351                                 uint32_t _relative_save_offset;
10352                                 _relative_save_offset = ndr->offset;
10353                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
10354                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10355                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10356                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
10357                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10358                                 ndr->offset = _relative_save_offset;
10359                         }
10360                         ndr->flags = _flags_save_string;
10361                 }
10362                 {
10363                         uint32_t _flags_save_string = ndr->flags;
10364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10365                         if (r->print_processor) {
10366                                 uint32_t _relative_save_offset;
10367                                 _relative_save_offset = ndr->offset;
10368                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
10369                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10370                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10371                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
10372                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10373                                 ndr->offset = _relative_save_offset;
10374                         }
10375                         ndr->flags = _flags_save_string;
10376                 }
10377                 {
10378                         uint32_t _flags_save_string = ndr->flags;
10379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10380                         if (r->vendor_setup) {
10381                                 uint32_t _relative_save_offset;
10382                                 _relative_save_offset = ndr->offset;
10383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
10384                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10385                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
10387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_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->color_profiles) {
10396                                 uint32_t _relative_save_offset;
10397                                 _relative_save_offset = ndr->offset;
10398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
10399                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10400                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10401                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
10402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10403                                 ndr->offset = _relative_save_offset;
10404                         }
10405                         ndr->flags = _flags_save_string_array;
10406                 }
10407                 {
10408                         uint32_t _flags_save_string = ndr->flags;
10409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10410                         if (r->inf_path) {
10411                                 uint32_t _relative_save_offset;
10412                                 _relative_save_offset = ndr->offset;
10413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
10414                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10415                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
10417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10418                                 ndr->offset = _relative_save_offset;
10419                         }
10420                         ndr->flags = _flags_save_string;
10421                 }
10422                 {
10423                         uint32_t _flags_save_string_array = ndr->flags;
10424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10425                         if (r->core_driver_dependencies) {
10426                                 uint32_t _relative_save_offset;
10427                                 _relative_save_offset = ndr->offset;
10428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
10429                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10430                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10431                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
10432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10433                                 ndr->offset = _relative_save_offset;
10434                         }
10435                         ndr->flags = _flags_save_string_array;
10436                 }
10437         }
10438         return NDR_ERR_SUCCESS;
10439 }
10440
10441 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
10442 {
10443         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
10444         ndr->depth++;
10445         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10446         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10447         ndr->depth++;
10448         if (r->driver_name) {
10449                 ndr_print_string(ndr, "driver_name", r->driver_name);
10450         }
10451         ndr->depth--;
10452         ndr_print_ptr(ndr, "architecture", r->architecture);
10453         ndr->depth++;
10454         if (r->architecture) {
10455                 ndr_print_string(ndr, "architecture", r->architecture);
10456         }
10457         ndr->depth--;
10458         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10459         ndr->depth++;
10460         if (r->driver_path) {
10461                 ndr_print_string(ndr, "driver_path", r->driver_path);
10462         }
10463         ndr->depth--;
10464         ndr_print_ptr(ndr, "data_file", r->data_file);
10465         ndr->depth++;
10466         if (r->data_file) {
10467                 ndr_print_string(ndr, "data_file", r->data_file);
10468         }
10469         ndr->depth--;
10470         ndr_print_ptr(ndr, "config_file", r->config_file);
10471         ndr->depth++;
10472         if (r->config_file) {
10473                 ndr_print_string(ndr, "config_file", r->config_file);
10474         }
10475         ndr->depth--;
10476         ndr_print_ptr(ndr, "help_file", r->help_file);
10477         ndr->depth++;
10478         if (r->help_file) {
10479                 ndr_print_string(ndr, "help_file", r->help_file);
10480         }
10481         ndr->depth--;
10482         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10483         ndr->depth++;
10484         if (r->monitor_name) {
10485                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10486         }
10487         ndr->depth--;
10488         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10489         ndr->depth++;
10490         if (r->default_datatype) {
10491                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10492         }
10493         ndr->depth--;
10494         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10495         ndr->depth++;
10496         if (r->dependent_files) {
10497                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10498         }
10499         ndr->depth--;
10500         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10501         ndr->depth++;
10502         if (r->previous_names) {
10503                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10504         }
10505         ndr->depth--;
10506         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10507         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10508         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10509         ndr->depth++;
10510         if (r->manufacturer_name) {
10511                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10512         }
10513         ndr->depth--;
10514         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10515         ndr->depth++;
10516         if (r->manufacturer_url) {
10517                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10518         }
10519         ndr->depth--;
10520         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10521         ndr->depth++;
10522         if (r->hardware_id) {
10523                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10524         }
10525         ndr->depth--;
10526         ndr_print_ptr(ndr, "provider", r->provider);
10527         ndr->depth++;
10528         if (r->provider) {
10529                 ndr_print_string(ndr, "provider", r->provider);
10530         }
10531         ndr->depth--;
10532         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10533         ndr->depth++;
10534         if (r->print_processor) {
10535                 ndr_print_string(ndr, "print_processor", r->print_processor);
10536         }
10537         ndr->depth--;
10538         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10539         ndr->depth++;
10540         if (r->vendor_setup) {
10541                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10542         }
10543         ndr->depth--;
10544         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10545         ndr->depth++;
10546         if (r->color_profiles) {
10547                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
10548         }
10549         ndr->depth--;
10550         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10551         ndr->depth++;
10552         if (r->inf_path) {
10553                 ndr_print_string(ndr, "inf_path", r->inf_path);
10554         }
10555         ndr->depth--;
10556         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10557         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10558         ndr->depth++;
10559         if (r->core_driver_dependencies) {
10560                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10561         }
10562         ndr->depth--;
10563         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10564         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10565         ndr->depth--;
10566 }
10567
10568 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
10569 {
10570         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
10571 }
10572
10573 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
10574 {
10575         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
10576         return NDR_ERR_SUCCESS;
10577 }
10578
10579 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
10580 {
10581         uint32_t v;
10582         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
10583         *r = v;
10584         return NDR_ERR_SUCCESS;
10585 }
10586
10587 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
10588 {
10589         const char *val = NULL;
10590
10591         switch (r) {
10592                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
10593                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
10594                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
10595                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
10596                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
10597         }
10598         ndr_print_enum(ndr, name, "ENUM", val, r);
10599 }
10600
10601 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
10602 {
10603         if (ndr_flags & NDR_SCALARS) {
10604                 NDR_CHECK(ndr_push_align(ndr, 4));
10605                 {
10606                         uint32_t _flags_save_string = ndr->flags;
10607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10608                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
10609                         ndr->flags = _flags_save_string;
10610                 }
10611                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
10612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
10613         }
10614         if (ndr_flags & NDR_BUFFERS) {
10615                 {
10616                         uint32_t _flags_save_string = ndr->flags;
10617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10618                         if (r->file_name) {
10619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
10620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
10621                         }
10622                         ndr->flags = _flags_save_string;
10623                 }
10624         }
10625         return NDR_ERR_SUCCESS;
10626 }
10627
10628 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
10629 {
10630         uint32_t _ptr_file_name;
10631         TALLOC_CTX *_mem_save_file_name_0;
10632         if (ndr_flags & NDR_SCALARS) {
10633                 NDR_CHECK(ndr_pull_align(ndr, 4));
10634                 {
10635                         uint32_t _flags_save_string = ndr->flags;
10636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10637                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
10638                         if (_ptr_file_name) {
10639                                 NDR_PULL_ALLOC(ndr, r->file_name);
10640                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
10641                         } else {
10642                                 r->file_name = NULL;
10643                         }
10644                         ndr->flags = _flags_save_string;
10645                 }
10646                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
10647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
10648         }
10649         if (ndr_flags & NDR_BUFFERS) {
10650                 {
10651                         uint32_t _flags_save_string = ndr->flags;
10652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10653                         if (r->file_name) {
10654                                 uint32_t _relative_save_offset;
10655                                 _relative_save_offset = ndr->offset;
10656                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
10657                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10658                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
10659                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
10660                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
10661                                 ndr->offset = _relative_save_offset;
10662                         }
10663                         ndr->flags = _flags_save_string;
10664                 }
10665         }
10666         return NDR_ERR_SUCCESS;
10667 }
10668
10669 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
10670 {
10671         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
10672         ndr->depth++;
10673         ndr_print_ptr(ndr, "file_name", r->file_name);
10674         ndr->depth++;
10675         if (r->file_name) {
10676                 ndr_print_string(ndr, "file_name", r->file_name);
10677         }
10678         ndr->depth--;
10679         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
10680         ndr_print_uint32(ndr, "file_version", r->file_version);
10681         ndr->depth--;
10682 }
10683
10684 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
10685 {
10686         uint32_t cntr_file_info_1;
10687         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
10688         ndr->depth++;
10689         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10690         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10691         ndr->depth++;
10692         if (r->driver_name) {
10693                 ndr_print_string(ndr, "driver_name", r->driver_name);
10694         }
10695         ndr->depth--;
10696         ndr_print_ptr(ndr, "architecture", r->architecture);
10697         ndr->depth++;
10698         if (r->architecture) {
10699                 ndr_print_string(ndr, "architecture", r->architecture);
10700         }
10701         ndr->depth--;
10702         ndr_print_ptr(ndr, "file_info", r->file_info);
10703         ndr->depth++;
10704         if (r->file_info) {
10705                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
10706                 ndr->depth++;
10707                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
10708                         char *idx_1=NULL;
10709                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
10710                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
10711                                 free(idx_1);
10712                         }
10713                 }
10714                 ndr->depth--;
10715         }
10716         ndr->depth--;
10717         ndr_print_uint32(ndr, "file_count", r->file_count);
10718         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10719         ndr->depth++;
10720         if (r->monitor_name) {
10721                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10722         }
10723         ndr->depth--;
10724         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10725         ndr->depth++;
10726         if (r->default_datatype) {
10727                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10728         }
10729         ndr->depth--;
10730         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10731         ndr->depth++;
10732         if (r->previous_names) {
10733                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10734         }
10735         ndr->depth--;
10736         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10737         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10738         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10739         ndr->depth++;
10740         if (r->manufacturer_name) {
10741                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10742         }
10743         ndr->depth--;
10744         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10745         ndr->depth++;
10746         if (r->manufacturer_url) {
10747                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10748         }
10749         ndr->depth--;
10750         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10751         ndr->depth++;
10752         if (r->hardware_id) {
10753                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10754         }
10755         ndr->depth--;
10756         ndr_print_ptr(ndr, "provider", r->provider);
10757         ndr->depth++;
10758         if (r->provider) {
10759                 ndr_print_string(ndr, "provider", r->provider);
10760         }
10761         ndr->depth--;
10762         ndr->depth--;
10763 }
10764
10765 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
10766 {
10767         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
10768 }
10769
10770 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
10771 {
10772         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10773         if (ndr_flags & NDR_SCALARS) {
10774                 int level = ndr_push_get_switch_value(ndr, r);
10775                 switch (level) {
10776                         case 1: {
10777                                 NDR_CHECK(ndr_push_align(ndr, 4));
10778                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10779                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10780                         break; }
10781
10782                         case 2: {
10783                                 NDR_CHECK(ndr_push_align(ndr, 4));
10784                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10785                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10786                         break; }
10787
10788                         case 3: {
10789                                 NDR_CHECK(ndr_push_align(ndr, 4));
10790                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10791                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10792                         break; }
10793
10794                         case 4: {
10795                                 NDR_CHECK(ndr_push_align(ndr, 4));
10796                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10797                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10798                         break; }
10799
10800                         case 5: {
10801                                 NDR_CHECK(ndr_push_align(ndr, 4));
10802                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10803                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10804                         break; }
10805
10806                         case 6: {
10807                                 NDR_CHECK(ndr_push_align(ndr, 8));
10808                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10809                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10810                         break; }
10811
10812                         case 8: {
10813                                 NDR_CHECK(ndr_push_align(ndr, 8));
10814                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10815                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10816                         break; }
10817
10818                         case 101: {
10819                                 NDR_CHECK(ndr_push_align(ndr, 8));
10820                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10821                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
10822                         break; }
10823
10824                         default: {
10825                         break; }
10826
10827                 }
10828         }
10829         if (ndr_flags & NDR_BUFFERS) {
10830                 int level = ndr_push_get_switch_value(ndr, r);
10831                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10832                 switch (level) {
10833                         case 1:
10834                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10835                         break;
10836
10837                         case 2:
10838                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10839                         break;
10840
10841                         case 3:
10842                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10843                         break;
10844
10845                         case 4:
10846                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10847                         break;
10848
10849                         case 5:
10850                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10851                         break;
10852
10853                         case 6:
10854                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10855                         break;
10856
10857                         case 8:
10858                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10859                         break;
10860
10861                         case 101:
10862                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
10863                         break;
10864
10865                         default:
10866                         break;
10867
10868                 }
10869         }
10870         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10871         return NDR_ERR_SUCCESS;
10872 }
10873
10874 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
10875 {
10876         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10877         int level;
10878         level = ndr_pull_get_switch_value(ndr, r);
10879         if (ndr_flags & NDR_SCALARS) {
10880                 switch (level) {
10881                         case 1: {
10882                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10883                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10884                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10885                         break; }
10886
10887                         case 2: {
10888                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10889                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10890                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10891                         break; }
10892
10893                         case 3: {
10894                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10895                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10896                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10897                         break; }
10898
10899                         case 4: {
10900                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10901                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10902                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10903                         break; }
10904
10905                         case 5: {
10906                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10907                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10908                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10909                         break; }
10910
10911                         case 6: {
10912                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10913                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10914                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10915                         break; }
10916
10917                         case 8: {
10918                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10919                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10920                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10921                         break; }
10922
10923                         case 101: {
10924                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10925                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10926                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
10927                         break; }
10928
10929                         default: {
10930                         break; }
10931
10932                 }
10933         }
10934         if (ndr_flags & NDR_BUFFERS) {
10935                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10936                 switch (level) {
10937                         case 1:
10938                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10939                         break;
10940
10941                         case 2:
10942                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10943                         break;
10944
10945                         case 3:
10946                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10947                         break;
10948
10949                         case 4:
10950                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10951                         break;
10952
10953                         case 5:
10954                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10955                         break;
10956
10957                         case 6:
10958                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10959                         break;
10960
10961                         case 8:
10962                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10963                         break;
10964
10965                         case 101:
10966                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
10967                         break;
10968
10969                         default:
10970                         break;
10971
10972                 }
10973         }
10974         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10975         return NDR_ERR_SUCCESS;
10976 }
10977
10978 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
10979 {
10980         int level;
10981         level = ndr_print_get_switch_value(ndr, r);
10982         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
10983         switch (level) {
10984                 case 1:
10985                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
10986                 break;
10987
10988                 case 2:
10989                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
10990                 break;
10991
10992                 case 3:
10993                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
10994                 break;
10995
10996                 case 4:
10997                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
10998                 break;
10999
11000                 case 5:
11001                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
11002                 break;
11003
11004                 case 6:
11005                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
11006                 break;
11007
11008                 case 8:
11009                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
11010                 break;
11011
11012                 case 101:
11013                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
11014                 break;
11015
11016                 default:
11017                 break;
11018
11019         }
11020 }
11021
11022 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
11023 {
11024         if (ndr_flags & NDR_SCALARS) {
11025                 NDR_CHECK(ndr_push_align(ndr, 4));
11026                 {
11027                         uint32_t _flags_save_string = ndr->flags;
11028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11029                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
11030                         ndr->flags = _flags_save_string;
11031                 }
11032         }
11033         if (ndr_flags & NDR_BUFFERS) {
11034         }
11035         return NDR_ERR_SUCCESS;
11036 }
11037
11038 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
11039 {
11040         if (ndr_flags & NDR_SCALARS) {
11041                 NDR_CHECK(ndr_pull_align(ndr, 4));
11042                 {
11043                         uint32_t _flags_save_string = ndr->flags;
11044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11045                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
11046                         ndr->flags = _flags_save_string;
11047                 }
11048         }
11049         if (ndr_flags & NDR_BUFFERS) {
11050         }
11051         return NDR_ERR_SUCCESS;
11052 }
11053
11054 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
11055 {
11056         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
11057         ndr->depth++;
11058         ndr_print_string(ndr, "directory_name", r->directory_name);
11059         ndr->depth--;
11060 }
11061
11062 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
11063 {
11064         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
11065 }
11066
11067 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
11068 {
11069         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11070         if (ndr_flags & NDR_SCALARS) {
11071                 int level = ndr_push_get_switch_value(ndr, r);
11072                 switch (level) {
11073                         case 1: {
11074                                 NDR_CHECK(ndr_push_align(ndr, 4));
11075                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11076                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11077                         break; }
11078
11079                         default: {
11080                                 NDR_CHECK(ndr_push_align(ndr, 4));
11081                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11082                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11083                         break; }
11084
11085                 }
11086         }
11087         if (ndr_flags & NDR_BUFFERS) {
11088                 int level = ndr_push_get_switch_value(ndr, r);
11089                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11090                 switch (level) {
11091                         case 1:
11092                         break;
11093
11094                         default:
11095                         break;
11096
11097                 }
11098         }
11099         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11100         return NDR_ERR_SUCCESS;
11101 }
11102
11103 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
11104 {
11105         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11106         int level;
11107         level = ndr_pull_get_switch_value(ndr, r);
11108         if (ndr_flags & NDR_SCALARS) {
11109                 switch (level) {
11110                         case 1: {
11111                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11112                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11113                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11114                         break; }
11115
11116                         default: {
11117                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11118                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11119                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11120                         break; }
11121
11122                 }
11123         }
11124         if (ndr_flags & NDR_BUFFERS) {
11125                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11126                 switch (level) {
11127                         case 1:
11128                         break;
11129
11130                         default:
11131                         break;
11132
11133                 }
11134         }
11135         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11136         return NDR_ERR_SUCCESS;
11137 }
11138
11139 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
11140 {
11141         int level;
11142         level = ndr_print_get_switch_value(ndr, r);
11143         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
11144         switch (level) {
11145                 case 1:
11146                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
11147                 break;
11148
11149                 default:
11150                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
11151                 break;
11152
11153         }
11154 }
11155
11156 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11157 {
11158         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
11159 }
11160
11161 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
11162 {
11163         if (ndr_flags & NDR_SCALARS) {
11164                 NDR_CHECK(ndr_push_align(ndr, 4));
11165                 {
11166                         uint32_t _flags_save_string = ndr->flags;
11167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11168                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
11169                         ndr->flags = _flags_save_string;
11170                 }
11171         }
11172         if (ndr_flags & NDR_BUFFERS) {
11173                 {
11174                         uint32_t _flags_save_string = ndr->flags;
11175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11176                         if (r->print_processor_name) {
11177                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
11178                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
11179                         }
11180                         ndr->flags = _flags_save_string;
11181                 }
11182         }
11183         return NDR_ERR_SUCCESS;
11184 }
11185
11186 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
11187 {
11188         uint32_t _ptr_print_processor_name;
11189         TALLOC_CTX *_mem_save_print_processor_name_0;
11190         if (ndr_flags & NDR_SCALARS) {
11191                 NDR_CHECK(ndr_pull_align(ndr, 4));
11192                 {
11193                         uint32_t _flags_save_string = ndr->flags;
11194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
11196                         if (_ptr_print_processor_name) {
11197                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
11198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
11199                         } else {
11200                                 r->print_processor_name = NULL;
11201                         }
11202                         ndr->flags = _flags_save_string;
11203                 }
11204         }
11205         if (ndr_flags & NDR_BUFFERS) {
11206                 {
11207                         uint32_t _flags_save_string = ndr->flags;
11208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11209                         if (r->print_processor_name) {
11210                                 uint32_t _relative_save_offset;
11211                                 _relative_save_offset = ndr->offset;
11212                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
11213                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11214                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
11215                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
11216                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
11217                                 ndr->offset = _relative_save_offset;
11218                         }
11219                         ndr->flags = _flags_save_string;
11220                 }
11221         }
11222         return NDR_ERR_SUCCESS;
11223 }
11224
11225 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
11226 {
11227         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
11228         ndr->depth++;
11229         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
11230         ndr->depth++;
11231         if (r->print_processor_name) {
11232                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
11233         }
11234         ndr->depth--;
11235         ndr->depth--;
11236 }
11237
11238 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
11239 {
11240         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11241         if (ndr_flags & NDR_SCALARS) {
11242                 int level = ndr_push_get_switch_value(ndr, r);
11243                 switch (level) {
11244                         case 1: {
11245                                 NDR_CHECK(ndr_push_align(ndr, 4));
11246                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11247                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11248                         break; }
11249
11250                         default: {
11251                         break; }
11252
11253                 }
11254         }
11255         if (ndr_flags & NDR_BUFFERS) {
11256                 int level = ndr_push_get_switch_value(ndr, r);
11257                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11258                 switch (level) {
11259                         case 1:
11260                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11261                         break;
11262
11263                         default:
11264                         break;
11265
11266                 }
11267         }
11268         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11269         return NDR_ERR_SUCCESS;
11270 }
11271
11272 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
11273 {
11274         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11275         int level;
11276         level = ndr_pull_get_switch_value(ndr, r);
11277         if (ndr_flags & NDR_SCALARS) {
11278                 switch (level) {
11279                         case 1: {
11280                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11281                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11282                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11283                         break; }
11284
11285                         default: {
11286                         break; }
11287
11288                 }
11289         }
11290         if (ndr_flags & NDR_BUFFERS) {
11291                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11292                 switch (level) {
11293                         case 1:
11294                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11295                         break;
11296
11297                         default:
11298                         break;
11299
11300                 }
11301         }
11302         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11303         return NDR_ERR_SUCCESS;
11304 }
11305
11306 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
11307 {
11308         int level;
11309         level = ndr_print_get_switch_value(ndr, r);
11310         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
11311         switch (level) {
11312                 case 1:
11313                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
11314                 break;
11315
11316                 default:
11317                 break;
11318
11319         }
11320 }
11321
11322 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11323 {
11324         if (ndr_flags & NDR_SCALARS) {
11325                 NDR_CHECK(ndr_push_align(ndr, 4));
11326                 {
11327                         uint32_t _flags_save_string = ndr->flags;
11328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11329                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
11330                         ndr->flags = _flags_save_string;
11331                 }
11332         }
11333         if (ndr_flags & NDR_BUFFERS) {
11334         }
11335         return NDR_ERR_SUCCESS;
11336 }
11337
11338 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
11339 {
11340         if (ndr_flags & NDR_SCALARS) {
11341                 NDR_CHECK(ndr_pull_align(ndr, 4));
11342                 {
11343                         uint32_t _flags_save_string = ndr->flags;
11344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11345                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
11346                         ndr->flags = _flags_save_string;
11347                 }
11348         }
11349         if (ndr_flags & NDR_BUFFERS) {
11350         }
11351         return NDR_ERR_SUCCESS;
11352 }
11353
11354 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
11355 {
11356         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
11357         ndr->depth++;
11358         ndr_print_string(ndr, "directory_name", r->directory_name);
11359         ndr->depth--;
11360 }
11361
11362 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
11363 {
11364         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
11365 }
11366
11367 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
11368 {
11369         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11370         if (ndr_flags & NDR_SCALARS) {
11371                 int level = ndr_push_get_switch_value(ndr, r);
11372                 switch (level) {
11373                         case 1: {
11374                                 NDR_CHECK(ndr_push_align(ndr, 4));
11375                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11376                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11377                         break; }
11378
11379                         default: {
11380                         break; }
11381
11382                 }
11383         }
11384         if (ndr_flags & NDR_BUFFERS) {
11385                 int level = ndr_push_get_switch_value(ndr, r);
11386                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11387                 switch (level) {
11388                         case 1:
11389                         break;
11390
11391                         default:
11392                         break;
11393
11394                 }
11395         }
11396         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11397         return NDR_ERR_SUCCESS;
11398 }
11399
11400 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
11401 {
11402         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11403         int level;
11404         level = ndr_pull_get_switch_value(ndr, r);
11405         if (ndr_flags & NDR_SCALARS) {
11406                 switch (level) {
11407                         case 1: {
11408                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11409                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11410                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
11411                         break; }
11412
11413                         default: {
11414                         break; }
11415
11416                 }
11417         }
11418         if (ndr_flags & NDR_BUFFERS) {
11419                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11420                 switch (level) {
11421                         case 1:
11422                         break;
11423
11424                         default:
11425                         break;
11426
11427                 }
11428         }
11429         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11430         return NDR_ERR_SUCCESS;
11431 }
11432
11433 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
11434 {
11435         int level;
11436         level = ndr_print_get_switch_value(ndr, r);
11437         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
11438         switch (level) {
11439                 case 1:
11440                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
11441                 break;
11442
11443                 default:
11444                 break;
11445
11446         }
11447 }
11448
11449 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11450 {
11451         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
11452 }
11453
11454 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
11455 {
11456         if (ndr_flags & NDR_SCALARS) {
11457                 NDR_CHECK(ndr_push_align(ndr, 4));
11458                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
11459                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
11460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
11461         }
11462         if (ndr_flags & NDR_BUFFERS) {
11463                 if (r->document_name) {
11464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11468                 }
11469                 if (r->output_file) {
11470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11473                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11474                 }
11475                 if (r->datatype) {
11476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11477                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11478                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11479                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11480                 }
11481         }
11482         return NDR_ERR_SUCCESS;
11483 }
11484
11485 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
11486 {
11487         uint32_t _ptr_document_name;
11488         TALLOC_CTX *_mem_save_document_name_0;
11489         uint32_t _ptr_output_file;
11490         TALLOC_CTX *_mem_save_output_file_0;
11491         uint32_t _ptr_datatype;
11492         TALLOC_CTX *_mem_save_datatype_0;
11493         if (ndr_flags & NDR_SCALARS) {
11494                 NDR_CHECK(ndr_pull_align(ndr, 4));
11495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
11496                 if (_ptr_document_name) {
11497                         NDR_PULL_ALLOC(ndr, r->document_name);
11498                 } else {
11499                         r->document_name = NULL;
11500                 }
11501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
11502                 if (_ptr_output_file) {
11503                         NDR_PULL_ALLOC(ndr, r->output_file);
11504                 } else {
11505                         r->output_file = NULL;
11506                 }
11507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
11508                 if (_ptr_datatype) {
11509                         NDR_PULL_ALLOC(ndr, r->datatype);
11510                 } else {
11511                         r->datatype = NULL;
11512                 }
11513         }
11514         if (ndr_flags & NDR_BUFFERS) {
11515                 if (r->document_name) {
11516                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11517                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
11518                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
11519                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
11520                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
11521                                 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));
11522                         }
11523                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
11524                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
11525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
11526                 }
11527                 if (r->output_file) {
11528                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11529                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
11530                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
11531                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
11532                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
11533                                 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));
11534                         }
11535                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
11536                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
11537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
11538                 }
11539                 if (r->datatype) {
11540                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11541                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
11542                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
11543                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
11544                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
11545                                 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));
11546                         }
11547                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
11548                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
11549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
11550                 }
11551         }
11552         return NDR_ERR_SUCCESS;
11553 }
11554
11555 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
11556 {
11557         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
11558         ndr->depth++;
11559         ndr_print_ptr(ndr, "document_name", r->document_name);
11560         ndr->depth++;
11561         if (r->document_name) {
11562                 ndr_print_string(ndr, "document_name", r->document_name);
11563         }
11564         ndr->depth--;
11565         ndr_print_ptr(ndr, "output_file", r->output_file);
11566         ndr->depth++;
11567         if (r->output_file) {
11568                 ndr_print_string(ndr, "output_file", r->output_file);
11569         }
11570         ndr->depth--;
11571         ndr_print_ptr(ndr, "datatype", r->datatype);
11572         ndr->depth++;
11573         if (r->datatype) {
11574                 ndr_print_string(ndr, "datatype", r->datatype);
11575         }
11576         ndr->depth--;
11577         ndr->depth--;
11578 }
11579
11580 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
11581 {
11582         if (ndr_flags & NDR_SCALARS) {
11583                 int level = ndr_push_get_switch_value(ndr, r);
11584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11585                 switch (level) {
11586                         case 1: {
11587                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
11588                         break; }
11589
11590                         case 2: {
11591                         break; }
11592
11593                         case 3: {
11594                         break; }
11595
11596                         default: {
11597                         break; }
11598
11599                 }
11600         }
11601         if (ndr_flags & NDR_BUFFERS) {
11602                 int level = ndr_push_get_switch_value(ndr, r);
11603                 switch (level) {
11604                         case 1:
11605                                 if (r->info1) {
11606                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11607                                 }
11608                         break;
11609
11610                         case 2:
11611                         break;
11612
11613                         case 3:
11614                         break;
11615
11616                         default:
11617                         break;
11618
11619                 }
11620         }
11621         return NDR_ERR_SUCCESS;
11622 }
11623
11624 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
11625 {
11626         int level;
11627         uint32_t _level;
11628         TALLOC_CTX *_mem_save_info1_0;
11629         level = ndr_pull_get_switch_value(ndr, r);
11630         if (ndr_flags & NDR_SCALARS) {
11631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11632                 if (_level != level) {
11633                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11634                 }
11635                 switch (level) {
11636                         case 1: {
11637                                 uint32_t _ptr_info1;
11638                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
11639                                 if (_ptr_info1) {
11640                                         NDR_PULL_ALLOC(ndr, r->info1);
11641                                 } else {
11642                                         r->info1 = NULL;
11643                                 }
11644                         break; }
11645
11646                         case 2: {
11647                         break; }
11648
11649                         case 3: {
11650                         break; }
11651
11652                         default: {
11653                         break; }
11654
11655                 }
11656         }
11657         if (ndr_flags & NDR_BUFFERS) {
11658                 switch (level) {
11659                         case 1:
11660                                 if (r->info1) {
11661                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11662                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
11663                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11664                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
11665                                 }
11666                         break;
11667
11668                         case 2:
11669                         break;
11670
11671                         case 3:
11672                         break;
11673
11674                         default:
11675                         break;
11676
11677                 }
11678         }
11679         return NDR_ERR_SUCCESS;
11680 }
11681
11682 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
11683 {
11684         int level;
11685         level = ndr_print_get_switch_value(ndr, r);
11686         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
11687         switch (level) {
11688                 case 1:
11689                         ndr_print_ptr(ndr, "info1", r->info1);
11690                         ndr->depth++;
11691                         if (r->info1) {
11692                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
11693                         }
11694                         ndr->depth--;
11695                 break;
11696
11697                 case 2:
11698                 break;
11699
11700                 case 3:
11701                 break;
11702
11703                 default:
11704                 break;
11705
11706         }
11707 }
11708
11709 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
11710 {
11711         if (ndr_flags & NDR_SCALARS) {
11712                 NDR_CHECK(ndr_push_align(ndr, 4));
11713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
11714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11718                 {
11719                         uint32_t _flags_save_string = ndr->flags;
11720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11721                         {
11722                                 struct ndr_push *_ndr_extra_string;
11723                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11724                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11725                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11726                         }
11727                         ndr->flags = _flags_save_string;
11728                 }
11729         }
11730         if (ndr_flags & NDR_BUFFERS) {
11731         }
11732         return NDR_ERR_SUCCESS;
11733 }
11734
11735 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
11736 {
11737         if (ndr_flags & NDR_SCALARS) {
11738                 NDR_CHECK(ndr_pull_align(ndr, 4));
11739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
11744                 {
11745                         uint32_t _flags_save_string = ndr->flags;
11746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11747                         {
11748                                 struct ndr_pull *_ndr_extra_string;
11749                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11750                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11751                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11752                         }
11753                         ndr->flags = _flags_save_string;
11754                 }
11755         }
11756         if (ndr_flags & NDR_BUFFERS) {
11757         }
11758         return NDR_ERR_SUCCESS;
11759 }
11760
11761 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
11762 {
11763         ndr_print_struct(ndr, name, "spoolss_OSVersion");
11764         ndr->depth++;
11765         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);
11766         ndr_print_uint32(ndr, "major", r->major);
11767         ndr_print_uint32(ndr, "minor", r->minor);
11768         ndr_print_uint32(ndr, "build", r->build);
11769         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
11770         ndr_print_string(ndr, "extra_string", r->extra_string);
11771         ndr->depth--;
11772 }
11773
11774 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
11775 {
11776         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
11777 }
11778
11779 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
11780 {
11781         if (ndr_flags & NDR_SCALARS) {
11782                 NDR_CHECK(ndr_push_align(ndr, 4));
11783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
11784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11788                 {
11789                         uint32_t _flags_save_string = ndr->flags;
11790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11791                         {
11792                                 struct ndr_push *_ndr_extra_string;
11793                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11794                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11795                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11796                         }
11797                         ndr->flags = _flags_save_string;
11798                 }
11799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
11800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
11801         }
11802         if (ndr_flags & NDR_BUFFERS) {
11803         }
11804         return NDR_ERR_SUCCESS;
11805 }
11806
11807 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
11808 {
11809         if (ndr_flags & NDR_SCALARS) {
11810                 NDR_CHECK(ndr_pull_align(ndr, 4));
11811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
11816                 {
11817                         uint32_t _flags_save_string = ndr->flags;
11818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11819                         {
11820                                 struct ndr_pull *_ndr_extra_string;
11821                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11822                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11823                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11824                         }
11825                         ndr->flags = _flags_save_string;
11826                 }
11827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
11828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
11829         }
11830         if (ndr_flags & NDR_BUFFERS) {
11831         }
11832         return NDR_ERR_SUCCESS;
11833 }
11834
11835 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
11836 {
11837         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
11838         ndr->depth++;
11839         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);
11840         ndr_print_uint32(ndr, "major", r->major);
11841         ndr_print_uint32(ndr, "minor", r->minor);
11842         ndr_print_uint32(ndr, "build", r->build);
11843         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
11844         ndr_print_string(ndr, "extra_string", r->extra_string);
11845         ndr_print_uint32(ndr, "unknown2", r->unknown2);
11846         ndr_print_uint32(ndr, "unknown3", r->unknown3);
11847         ndr->depth--;
11848 }
11849
11850 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
11851 {
11852         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
11853 }
11854
11855 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
11856 {
11857         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11858         return NDR_ERR_SUCCESS;
11859 }
11860
11861 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
11862 {
11863         uint32_t v;
11864         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11865         *r = v;
11866         return NDR_ERR_SUCCESS;
11867 }
11868
11869 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
11870 {
11871         const char *val = NULL;
11872
11873         switch (r) {
11874                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
11875                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
11876                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
11877                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
11878                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
11879         }
11880         ndr_print_enum(ndr, name, "ENUM", val, r);
11881 }
11882
11883 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
11884 {
11885         if (ndr_flags & NDR_SCALARS) {
11886                 int level = ndr_push_get_switch_value(ndr, r);
11887                 switch (level) {
11888                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11889                         break; }
11890
11891                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11892                                 {
11893                                         uint32_t _flags_save_string = ndr->flags;
11894                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11895                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
11896                                         ndr->flags = _flags_save_string;
11897                                 }
11898                         break; }
11899
11900                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11901                                 {
11902                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11903                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11904                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11905                                         ndr->flags = _flags_save_DATA_BLOB;
11906                                 }
11907                         break; }
11908
11909                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11910                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
11911                         break; }
11912
11913                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11914                                 {
11915                                         uint32_t _flags_save_string_array = ndr->flags;
11916                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11917                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
11918                                         ndr->flags = _flags_save_string_array;
11919                                 }
11920                         break; }
11921
11922                         default: {
11923                                 {
11924                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11925                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11926                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
11927                                         ndr->flags = _flags_save_DATA_BLOB;
11928                                 }
11929                         break; }
11930
11931                 }
11932         }
11933         if (ndr_flags & NDR_BUFFERS) {
11934                 int level = ndr_push_get_switch_value(ndr, r);
11935                 switch (level) {
11936                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11937                         break;
11938
11939                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11940                         break;
11941
11942                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11943                         break;
11944
11945                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11946                         break;
11947
11948                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11949                         break;
11950
11951                         default:
11952                         break;
11953
11954                 }
11955         }
11956         return NDR_ERR_SUCCESS;
11957 }
11958
11959 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
11960 {
11961         int level;
11962         level = ndr_pull_get_switch_value(ndr, r);
11963         if (ndr_flags & NDR_SCALARS) {
11964                 switch (level) {
11965                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11966                         break; }
11967
11968                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11969                                 {
11970                                         uint32_t _flags_save_string = ndr->flags;
11971                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11972                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
11973                                         ndr->flags = _flags_save_string;
11974                                 }
11975                         break; }
11976
11977                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11978                                 {
11979                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11980                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11981                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
11982                                         ndr->flags = _flags_save_DATA_BLOB;
11983                                 }
11984                         break; }
11985
11986                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11987                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
11988                         break; }
11989
11990                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11991                                 {
11992                                         uint32_t _flags_save_string_array = ndr->flags;
11993                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11994                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
11995                                         ndr->flags = _flags_save_string_array;
11996                                 }
11997                         break; }
11998
11999                         default: {
12000                                 {
12001                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
12002                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
12003                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
12004                                         ndr->flags = _flags_save_DATA_BLOB;
12005                                 }
12006                         break; }
12007
12008                 }
12009         }
12010         if (ndr_flags & NDR_BUFFERS) {
12011                 switch (level) {
12012                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
12013                         break;
12014
12015                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
12016                         break;
12017
12018                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
12019                         break;
12020
12021                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
12022                         break;
12023
12024                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
12025                         break;
12026
12027                         default:
12028                         break;
12029
12030                 }
12031         }
12032         return NDR_ERR_SUCCESS;
12033 }
12034
12035 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
12036 {
12037         int level;
12038         level = ndr_print_get_switch_value(ndr, r);
12039         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
12040         switch (level) {
12041                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
12042                 break;
12043
12044                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
12045                         ndr_print_string(ndr, "string", r->string);
12046                 break;
12047
12048                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
12049                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
12050                 break;
12051
12052                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
12053                         ndr_print_uint32(ndr, "value", r->value);
12054                 break;
12055
12056                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
12057                         ndr_print_string_array(ndr, "string_array", r->string_array);
12058                 break;
12059
12060                 default:
12061                         ndr_print_DATA_BLOB(ndr, "data", r->data);
12062                 break;
12063
12064         }
12065 }
12066
12067 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12068 {
12069         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
12070 }
12071
12072 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
12073 {
12074         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12075         return NDR_ERR_SUCCESS;
12076 }
12077
12078 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
12079 {
12080         uint32_t v;
12081         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12082         *r = v;
12083         return NDR_ERR_SUCCESS;
12084 }
12085
12086 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
12087 {
12088         const char *val = NULL;
12089
12090         switch (r) {
12091                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
12092                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
12093                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
12094         }
12095         ndr_print_enum(ndr, name, "ENUM", val, r);
12096 }
12097
12098 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
12099 {
12100         if (ndr_flags & NDR_SCALARS) {
12101                 NDR_CHECK(ndr_push_align(ndr, 4));
12102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
12103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
12104         }
12105         if (ndr_flags & NDR_BUFFERS) {
12106         }
12107         return NDR_ERR_SUCCESS;
12108 }
12109
12110 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
12111 {
12112         if (ndr_flags & NDR_SCALARS) {
12113                 NDR_CHECK(ndr_pull_align(ndr, 4));
12114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
12115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
12116         }
12117         if (ndr_flags & NDR_BUFFERS) {
12118         }
12119         return NDR_ERR_SUCCESS;
12120 }
12121
12122 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
12123 {
12124         ndr_print_struct(ndr, name, "spoolss_FormSize");
12125         ndr->depth++;
12126         ndr_print_uint32(ndr, "width", r->width);
12127         ndr_print_uint32(ndr, "height", r->height);
12128         ndr->depth--;
12129 }
12130
12131 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
12132 {
12133         if (ndr_flags & NDR_SCALARS) {
12134                 NDR_CHECK(ndr_push_align(ndr, 4));
12135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
12136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
12137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
12138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
12139         }
12140         if (ndr_flags & NDR_BUFFERS) {
12141         }
12142         return NDR_ERR_SUCCESS;
12143 }
12144
12145 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
12146 {
12147         if (ndr_flags & NDR_SCALARS) {
12148                 NDR_CHECK(ndr_pull_align(ndr, 4));
12149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
12150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
12151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
12152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
12153         }
12154         if (ndr_flags & NDR_BUFFERS) {
12155         }
12156         return NDR_ERR_SUCCESS;
12157 }
12158
12159 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
12160 {
12161         ndr_print_struct(ndr, name, "spoolss_FormArea");
12162         ndr->depth++;
12163         ndr_print_uint32(ndr, "left", r->left);
12164         ndr_print_uint32(ndr, "top", r->top);
12165         ndr_print_uint32(ndr, "right", r->right);
12166         ndr_print_uint32(ndr, "bottom", r->bottom);
12167         ndr->depth--;
12168 }
12169
12170 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
12171 {
12172         if (ndr_flags & NDR_SCALARS) {
12173                 NDR_CHECK(ndr_push_align(ndr, 4));
12174                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
12175                 {
12176                         uint32_t _flags_save_string = ndr->flags;
12177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12178                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
12179                         ndr->flags = _flags_save_string;
12180                 }
12181                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12182                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12183         }
12184         if (ndr_flags & NDR_BUFFERS) {
12185                 {
12186                         uint32_t _flags_save_string = ndr->flags;
12187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12188                         if (r->form_name) {
12189                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
12190                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
12191                         }
12192                         ndr->flags = _flags_save_string;
12193                 }
12194         }
12195         return NDR_ERR_SUCCESS;
12196 }
12197
12198 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
12199 {
12200         uint32_t _ptr_form_name;
12201         TALLOC_CTX *_mem_save_form_name_0;
12202         if (ndr_flags & NDR_SCALARS) {
12203                 NDR_CHECK(ndr_pull_align(ndr, 4));
12204                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
12205                 {
12206                         uint32_t _flags_save_string = ndr->flags;
12207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12208                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
12209                         if (_ptr_form_name) {
12210                                 NDR_PULL_ALLOC(ndr, r->form_name);
12211                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
12212                         } else {
12213                                 r->form_name = NULL;
12214                         }
12215                         ndr->flags = _flags_save_string;
12216                 }
12217                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12218                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12219         }
12220         if (ndr_flags & NDR_BUFFERS) {
12221                 {
12222                         uint32_t _flags_save_string = ndr->flags;
12223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12224                         if (r->form_name) {
12225                                 uint32_t _relative_save_offset;
12226                                 _relative_save_offset = ndr->offset;
12227                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
12228                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12229                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12230                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
12231                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12232                                 ndr->offset = _relative_save_offset;
12233                         }
12234                         ndr->flags = _flags_save_string;
12235                 }
12236         }
12237         return NDR_ERR_SUCCESS;
12238 }
12239
12240 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
12241 {
12242         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
12243         ndr->depth++;
12244         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12245         ndr_print_ptr(ndr, "form_name", r->form_name);
12246         ndr->depth++;
12247         if (r->form_name) {
12248                 ndr_print_string(ndr, "form_name", r->form_name);
12249         }
12250         ndr->depth--;
12251         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12252         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12253         ndr->depth--;
12254 }
12255
12256 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
12257 {
12258         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12259         if (ndr_flags & NDR_SCALARS) {
12260                 int level = ndr_push_get_switch_value(ndr, r);
12261                 switch (level) {
12262                         case 1: {
12263                                 NDR_CHECK(ndr_push_align(ndr, 4));
12264                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12265                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12266                         break; }
12267
12268                         default: {
12269                         break; }
12270
12271                 }
12272         }
12273         if (ndr_flags & NDR_BUFFERS) {
12274                 int level = ndr_push_get_switch_value(ndr, r);
12275                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12276                 switch (level) {
12277                         case 1:
12278                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12279                         break;
12280
12281                         default:
12282                         break;
12283
12284                 }
12285         }
12286         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12287         return NDR_ERR_SUCCESS;
12288 }
12289
12290 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
12291 {
12292         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12293         int level;
12294         level = ndr_pull_get_switch_value(ndr, r);
12295         if (ndr_flags & NDR_SCALARS) {
12296                 switch (level) {
12297                         case 1: {
12298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12300                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
12301                         break; }
12302
12303                         default: {
12304                         break; }
12305
12306                 }
12307         }
12308         if (ndr_flags & NDR_BUFFERS) {
12309                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12310                 switch (level) {
12311                         case 1:
12312                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
12313                         break;
12314
12315                         default:
12316                         break;
12317
12318                 }
12319         }
12320         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12321         return NDR_ERR_SUCCESS;
12322 }
12323
12324 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
12325 {
12326         int level;
12327         level = ndr_print_get_switch_value(ndr, r);
12328         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
12329         switch (level) {
12330                 case 1:
12331                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
12332                 break;
12333
12334                 default:
12335                 break;
12336
12337         }
12338 }
12339
12340 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12341 {
12342         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
12343 }
12344
12345 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
12346 {
12347         if (ndr_flags & NDR_SCALARS) {
12348                 NDR_CHECK(ndr_push_align(ndr, 4));
12349                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
12350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
12351                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12352                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12353         }
12354         if (ndr_flags & NDR_BUFFERS) {
12355                 if (r->form_name) {
12356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
12359                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12360                 }
12361         }
12362         return NDR_ERR_SUCCESS;
12363 }
12364
12365 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
12366 {
12367         uint32_t _ptr_form_name;
12368         TALLOC_CTX *_mem_save_form_name_0;
12369         if (ndr_flags & NDR_SCALARS) {
12370                 NDR_CHECK(ndr_pull_align(ndr, 4));
12371                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
12372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
12373                 if (_ptr_form_name) {
12374                         NDR_PULL_ALLOC(ndr, r->form_name);
12375                 } else {
12376                         r->form_name = NULL;
12377                 }
12378                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
12379                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
12380         }
12381         if (ndr_flags & NDR_BUFFERS) {
12382                 if (r->form_name) {
12383                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12384                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12385                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
12386                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
12387                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
12388                                 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));
12389                         }
12390                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
12391                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
12392                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12393                 }
12394         }
12395         return NDR_ERR_SUCCESS;
12396 }
12397
12398 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
12399 {
12400         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
12401         ndr->depth++;
12402         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12403         ndr_print_ptr(ndr, "form_name", r->form_name);
12404         ndr->depth++;
12405         if (r->form_name) {
12406                 ndr_print_string(ndr, "form_name", r->form_name);
12407         }
12408         ndr->depth--;
12409         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12410         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12411         ndr->depth--;
12412 }
12413
12414 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
12415 {
12416         if (ndr_flags & NDR_SCALARS) {
12417                 int level = ndr_push_get_switch_value(ndr, r);
12418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12419                 switch (level) {
12420                         case 1: {
12421                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
12422                         break; }
12423
12424                         default:
12425                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12426                 }
12427         }
12428         if (ndr_flags & NDR_BUFFERS) {
12429                 int level = ndr_push_get_switch_value(ndr, r);
12430                 switch (level) {
12431                         case 1:
12432                                 if (r->info1) {
12433                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12434                                 }
12435                         break;
12436
12437                         default:
12438                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12439                 }
12440         }
12441         return NDR_ERR_SUCCESS;
12442 }
12443
12444 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
12445 {
12446         int level;
12447         uint32_t _level;
12448         TALLOC_CTX *_mem_save_info1_0;
12449         level = ndr_pull_get_switch_value(ndr, r);
12450         if (ndr_flags & NDR_SCALARS) {
12451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12452                 if (_level != level) {
12453                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12454                 }
12455                 switch (level) {
12456                         case 1: {
12457                                 uint32_t _ptr_info1;
12458                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
12459                                 if (_ptr_info1) {
12460                                         NDR_PULL_ALLOC(ndr, r->info1);
12461                                 } else {
12462                                         r->info1 = NULL;
12463                                 }
12464                         break; }
12465
12466                         default:
12467                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12468                 }
12469         }
12470         if (ndr_flags & NDR_BUFFERS) {
12471                 switch (level) {
12472                         case 1:
12473                                 if (r->info1) {
12474                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12475                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
12476                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12477                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
12478                                 }
12479                         break;
12480
12481                         default:
12482                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12483                 }
12484         }
12485         return NDR_ERR_SUCCESS;
12486 }
12487
12488 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
12489 {
12490         int level;
12491         level = ndr_print_get_switch_value(ndr, r);
12492         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
12493         switch (level) {
12494                 case 1:
12495                         ndr_print_ptr(ndr, "info1", r->info1);
12496                         ndr->depth++;
12497                         if (r->info1) {
12498                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
12499                         }
12500                         ndr->depth--;
12501                 break;
12502
12503                 default:
12504                         ndr_print_bad_level(ndr, name, level);
12505         }
12506 }
12507
12508 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
12509 {
12510         if (ndr_flags & NDR_SCALARS) {
12511                 NDR_CHECK(ndr_push_align(ndr, 4));
12512                 {
12513                         uint32_t _flags_save_string = ndr->flags;
12514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12515                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12516                         ndr->flags = _flags_save_string;
12517                 }
12518         }
12519         if (ndr_flags & NDR_BUFFERS) {
12520                 {
12521                         uint32_t _flags_save_string = ndr->flags;
12522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12523                         if (r->port_name) {
12524                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12525                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12526                         }
12527                         ndr->flags = _flags_save_string;
12528                 }
12529         }
12530         return NDR_ERR_SUCCESS;
12531 }
12532
12533 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
12534 {
12535         uint32_t _ptr_port_name;
12536         TALLOC_CTX *_mem_save_port_name_0;
12537         if (ndr_flags & NDR_SCALARS) {
12538                 NDR_CHECK(ndr_pull_align(ndr, 4));
12539                 {
12540                         uint32_t _flags_save_string = ndr->flags;
12541                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12542                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12543                         if (_ptr_port_name) {
12544                                 NDR_PULL_ALLOC(ndr, r->port_name);
12545                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12546                         } else {
12547                                 r->port_name = NULL;
12548                         }
12549                         ndr->flags = _flags_save_string;
12550                 }
12551         }
12552         if (ndr_flags & NDR_BUFFERS) {
12553                 {
12554                         uint32_t _flags_save_string = ndr->flags;
12555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12556                         if (r->port_name) {
12557                                 uint32_t _relative_save_offset;
12558                                 _relative_save_offset = ndr->offset;
12559                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12560                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12561                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12562                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12563                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12564                                 ndr->offset = _relative_save_offset;
12565                         }
12566                         ndr->flags = _flags_save_string;
12567                 }
12568         }
12569         return NDR_ERR_SUCCESS;
12570 }
12571
12572 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
12573 {
12574         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
12575         ndr->depth++;
12576         ndr_print_ptr(ndr, "port_name", r->port_name);
12577         ndr->depth++;
12578         if (r->port_name) {
12579                 ndr_print_string(ndr, "port_name", r->port_name);
12580         }
12581         ndr->depth--;
12582         ndr->depth--;
12583 }
12584
12585 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12586 {
12587         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12588         return NDR_ERR_SUCCESS;
12589 }
12590
12591 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12592 {
12593         uint32_t v;
12594         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12595         *r = v;
12596         return NDR_ERR_SUCCESS;
12597 }
12598
12599 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
12600 {
12601         ndr_print_uint32(ndr, name, r);
12602         ndr->depth++;
12603         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
12604         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
12605         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
12606         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
12607         ndr->depth--;
12608 }
12609
12610 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
12611 {
12612         if (ndr_flags & NDR_SCALARS) {
12613                 NDR_CHECK(ndr_push_align(ndr, 4));
12614                 {
12615                         uint32_t _flags_save_string = ndr->flags;
12616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12617                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12618                         ndr->flags = _flags_save_string;
12619                 }
12620                 {
12621                         uint32_t _flags_save_string = ndr->flags;
12622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12623                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12624                         ndr->flags = _flags_save_string;
12625                 }
12626                 {
12627                         uint32_t _flags_save_string = ndr->flags;
12628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12629                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
12630                         ndr->flags = _flags_save_string;
12631                 }
12632                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
12633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12634         }
12635         if (ndr_flags & NDR_BUFFERS) {
12636                 {
12637                         uint32_t _flags_save_string = ndr->flags;
12638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12639                         if (r->port_name) {
12640                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12641                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12642                         }
12643                         ndr->flags = _flags_save_string;
12644                 }
12645                 {
12646                         uint32_t _flags_save_string = ndr->flags;
12647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12648                         if (r->monitor_name) {
12649                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12650                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12651                         }
12652                         ndr->flags = _flags_save_string;
12653                 }
12654                 {
12655                         uint32_t _flags_save_string = ndr->flags;
12656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12657                         if (r->description) {
12658                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
12659                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
12660                         }
12661                         ndr->flags = _flags_save_string;
12662                 }
12663         }
12664         return NDR_ERR_SUCCESS;
12665 }
12666
12667 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
12668 {
12669         uint32_t _ptr_port_name;
12670         TALLOC_CTX *_mem_save_port_name_0;
12671         uint32_t _ptr_monitor_name;
12672         TALLOC_CTX *_mem_save_monitor_name_0;
12673         uint32_t _ptr_description;
12674         TALLOC_CTX *_mem_save_description_0;
12675         if (ndr_flags & NDR_SCALARS) {
12676                 NDR_CHECK(ndr_pull_align(ndr, 4));
12677                 {
12678                         uint32_t _flags_save_string = ndr->flags;
12679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12681                         if (_ptr_port_name) {
12682                                 NDR_PULL_ALLOC(ndr, r->port_name);
12683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12684                         } else {
12685                                 r->port_name = NULL;
12686                         }
12687                         ndr->flags = _flags_save_string;
12688                 }
12689                 {
12690                         uint32_t _flags_save_string = ndr->flags;
12691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12692                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12693                         if (_ptr_monitor_name) {
12694                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12695                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12696                         } else {
12697                                 r->monitor_name = NULL;
12698                         }
12699                         ndr->flags = _flags_save_string;
12700                 }
12701                 {
12702                         uint32_t _flags_save_string = ndr->flags;
12703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12704                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
12705                         if (_ptr_description) {
12706                                 NDR_PULL_ALLOC(ndr, r->description);
12707                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
12708                         } else {
12709                                 r->description = NULL;
12710                         }
12711                         ndr->flags = _flags_save_string;
12712                 }
12713                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
12714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12715         }
12716         if (ndr_flags & NDR_BUFFERS) {
12717                 {
12718                         uint32_t _flags_save_string = ndr->flags;
12719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12720                         if (r->port_name) {
12721                                 uint32_t _relative_save_offset;
12722                                 _relative_save_offset = ndr->offset;
12723                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12724                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12725                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12726                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12727                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12728                                 ndr->offset = _relative_save_offset;
12729                         }
12730                         ndr->flags = _flags_save_string;
12731                 }
12732                 {
12733                         uint32_t _flags_save_string = ndr->flags;
12734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12735                         if (r->monitor_name) {
12736                                 uint32_t _relative_save_offset;
12737                                 _relative_save_offset = ndr->offset;
12738                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12739                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12740                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12741                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12742                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12743                                 ndr->offset = _relative_save_offset;
12744                         }
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                         if (r->description) {
12751                                 uint32_t _relative_save_offset;
12752                                 _relative_save_offset = ndr->offset;
12753                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
12754                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
12755                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
12756                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
12757                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
12758                                 ndr->offset = _relative_save_offset;
12759                         }
12760                         ndr->flags = _flags_save_string;
12761                 }
12762         }
12763         return NDR_ERR_SUCCESS;
12764 }
12765
12766 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
12767 {
12768         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
12769         ndr->depth++;
12770         ndr_print_ptr(ndr, "port_name", r->port_name);
12771         ndr->depth++;
12772         if (r->port_name) {
12773                 ndr_print_string(ndr, "port_name", r->port_name);
12774         }
12775         ndr->depth--;
12776         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12777         ndr->depth++;
12778         if (r->monitor_name) {
12779                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12780         }
12781         ndr->depth--;
12782         ndr_print_ptr(ndr, "description", r->description);
12783         ndr->depth++;
12784         if (r->description) {
12785                 ndr_print_string(ndr, "description", r->description);
12786         }
12787         ndr->depth--;
12788         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
12789         ndr_print_uint32(ndr, "reserved", r->reserved);
12790         ndr->depth--;
12791 }
12792
12793 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
12794 {
12795         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12796         if (ndr_flags & NDR_SCALARS) {
12797                 int level = ndr_push_get_switch_value(ndr, r);
12798                 switch (level) {
12799                         case 1: {
12800                                 NDR_CHECK(ndr_push_align(ndr, 4));
12801                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12802                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12803                         break; }
12804
12805                         case 2: {
12806                                 NDR_CHECK(ndr_push_align(ndr, 4));
12807                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12808                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12809                         break; }
12810
12811                         case 3: {
12812                         break; }
12813
12814                         default: {
12815                         break; }
12816
12817                 }
12818         }
12819         if (ndr_flags & NDR_BUFFERS) {
12820                 int level = ndr_push_get_switch_value(ndr, r);
12821                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12822                 switch (level) {
12823                         case 1:
12824                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12825                         break;
12826
12827                         case 2:
12828                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12829                         break;
12830
12831                         case 3:
12832                         break;
12833
12834                         default:
12835                         break;
12836
12837                 }
12838         }
12839         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12840         return NDR_ERR_SUCCESS;
12841 }
12842
12843 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
12844 {
12845         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12846         int level;
12847         level = ndr_pull_get_switch_value(ndr, r);
12848         if (ndr_flags & NDR_SCALARS) {
12849                 switch (level) {
12850                         case 1: {
12851                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12852                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12853                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12854                         break; }
12855
12856                         case 2: {
12857                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12858                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12859                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12860                         break; }
12861
12862                         case 3: {
12863                         break; }
12864
12865                         default: {
12866                         break; }
12867
12868                 }
12869         }
12870         if (ndr_flags & NDR_BUFFERS) {
12871                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12872                 switch (level) {
12873                         case 1:
12874                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12875                         break;
12876
12877                         case 2:
12878                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12879                         break;
12880
12881                         case 3:
12882                         break;
12883
12884                         default:
12885                         break;
12886
12887                 }
12888         }
12889         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12890         return NDR_ERR_SUCCESS;
12891 }
12892
12893 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
12894 {
12895         int level;
12896         level = ndr_print_get_switch_value(ndr, r);
12897         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
12898         switch (level) {
12899                 case 1:
12900                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
12901                 break;
12902
12903                 case 2:
12904                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
12905                 break;
12906
12907                 case 3:
12908                 break;
12909
12910                 default:
12911                 break;
12912
12913         }
12914 }
12915
12916 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
12917 {
12918         if (ndr_flags & NDR_SCALARS) {
12919                 NDR_CHECK(ndr_push_align(ndr, 4));
12920                 {
12921                         uint32_t _flags_save_string = ndr->flags;
12922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12923                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12924                         ndr->flags = _flags_save_string;
12925                 }
12926         }
12927         if (ndr_flags & NDR_BUFFERS) {
12928                 {
12929                         uint32_t _flags_save_string = ndr->flags;
12930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12931                         if (r->monitor_name) {
12932                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12933                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12934                         }
12935                         ndr->flags = _flags_save_string;
12936                 }
12937         }
12938         return NDR_ERR_SUCCESS;
12939 }
12940
12941 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
12942 {
12943         uint32_t _ptr_monitor_name;
12944         TALLOC_CTX *_mem_save_monitor_name_0;
12945         if (ndr_flags & NDR_SCALARS) {
12946                 NDR_CHECK(ndr_pull_align(ndr, 4));
12947                 {
12948                         uint32_t _flags_save_string = ndr->flags;
12949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12951                         if (_ptr_monitor_name) {
12952                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12954                         } else {
12955                                 r->monitor_name = NULL;
12956                         }
12957                         ndr->flags = _flags_save_string;
12958                 }
12959         }
12960         if (ndr_flags & NDR_BUFFERS) {
12961                 {
12962                         uint32_t _flags_save_string = ndr->flags;
12963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12964                         if (r->monitor_name) {
12965                                 uint32_t _relative_save_offset;
12966                                 _relative_save_offset = ndr->offset;
12967                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12968                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12969                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12970                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12971                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12972                                 ndr->offset = _relative_save_offset;
12973                         }
12974                         ndr->flags = _flags_save_string;
12975                 }
12976         }
12977         return NDR_ERR_SUCCESS;
12978 }
12979
12980 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
12981 {
12982         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
12983         ndr->depth++;
12984         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12985         ndr->depth++;
12986         if (r->monitor_name) {
12987                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12988         }
12989         ndr->depth--;
12990         ndr->depth--;
12991 }
12992
12993 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
12994 {
12995         if (ndr_flags & NDR_SCALARS) {
12996                 NDR_CHECK(ndr_push_align(ndr, 4));
12997                 {
12998                         uint32_t _flags_save_string = ndr->flags;
12999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13000                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13001                         ndr->flags = _flags_save_string;
13002                 }
13003                 {
13004                         uint32_t _flags_save_string = ndr->flags;
13005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
13007                         ndr->flags = _flags_save_string;
13008                 }
13009                 {
13010                         uint32_t _flags_save_string = ndr->flags;
13011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
13013                         ndr->flags = _flags_save_string;
13014                 }
13015         }
13016         if (ndr_flags & NDR_BUFFERS) {
13017                 {
13018                         uint32_t _flags_save_string = ndr->flags;
13019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13020                         if (r->monitor_name) {
13021                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13022                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13023                         }
13024                         ndr->flags = _flags_save_string;
13025                 }
13026                 {
13027                         uint32_t _flags_save_string = ndr->flags;
13028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13029                         if (r->environment) {
13030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
13031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
13032                         }
13033                         ndr->flags = _flags_save_string;
13034                 }
13035                 {
13036                         uint32_t _flags_save_string = ndr->flags;
13037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13038                         if (r->dll_name) {
13039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
13040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
13041                         }
13042                         ndr->flags = _flags_save_string;
13043                 }
13044         }
13045         return NDR_ERR_SUCCESS;
13046 }
13047
13048 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
13049 {
13050         uint32_t _ptr_monitor_name;
13051         TALLOC_CTX *_mem_save_monitor_name_0;
13052         uint32_t _ptr_environment;
13053         TALLOC_CTX *_mem_save_environment_0;
13054         uint32_t _ptr_dll_name;
13055         TALLOC_CTX *_mem_save_dll_name_0;
13056         if (ndr_flags & NDR_SCALARS) {
13057                 NDR_CHECK(ndr_pull_align(ndr, 4));
13058                 {
13059                         uint32_t _flags_save_string = ndr->flags;
13060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13061                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13062                         if (_ptr_monitor_name) {
13063                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13064                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13065                         } else {
13066                                 r->monitor_name = NULL;
13067                         }
13068                         ndr->flags = _flags_save_string;
13069                 }
13070                 {
13071                         uint32_t _flags_save_string = ndr->flags;
13072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13073                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
13074                         if (_ptr_environment) {
13075                                 NDR_PULL_ALLOC(ndr, r->environment);
13076                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
13077                         } else {
13078                                 r->environment = NULL;
13079                         }
13080                         ndr->flags = _flags_save_string;
13081                 }
13082                 {
13083                         uint32_t _flags_save_string = ndr->flags;
13084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13085                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
13086                         if (_ptr_dll_name) {
13087                                 NDR_PULL_ALLOC(ndr, r->dll_name);
13088                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
13089                         } else {
13090                                 r->dll_name = NULL;
13091                         }
13092                         ndr->flags = _flags_save_string;
13093                 }
13094         }
13095         if (ndr_flags & NDR_BUFFERS) {
13096                 {
13097                         uint32_t _flags_save_string = ndr->flags;
13098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13099                         if (r->monitor_name) {
13100                                 uint32_t _relative_save_offset;
13101                                 _relative_save_offset = ndr->offset;
13102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13103                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13104                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13107                                 ndr->offset = _relative_save_offset;
13108                         }
13109                         ndr->flags = _flags_save_string;
13110                 }
13111                 {
13112                         uint32_t _flags_save_string = ndr->flags;
13113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13114                         if (r->environment) {
13115                                 uint32_t _relative_save_offset;
13116                                 _relative_save_offset = ndr->offset;
13117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
13118                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
13119                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
13120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
13121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
13122                                 ndr->offset = _relative_save_offset;
13123                         }
13124                         ndr->flags = _flags_save_string;
13125                 }
13126                 {
13127                         uint32_t _flags_save_string = ndr->flags;
13128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13129                         if (r->dll_name) {
13130                                 uint32_t _relative_save_offset;
13131                                 _relative_save_offset = ndr->offset;
13132                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
13133                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13134                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
13135                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
13136                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
13137                                 ndr->offset = _relative_save_offset;
13138                         }
13139                         ndr->flags = _flags_save_string;
13140                 }
13141         }
13142         return NDR_ERR_SUCCESS;
13143 }
13144
13145 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
13146 {
13147         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
13148         ndr->depth++;
13149         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13150         ndr->depth++;
13151         if (r->monitor_name) {
13152                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13153         }
13154         ndr->depth--;
13155         ndr_print_ptr(ndr, "environment", r->environment);
13156         ndr->depth++;
13157         if (r->environment) {
13158                 ndr_print_string(ndr, "environment", r->environment);
13159         }
13160         ndr->depth--;
13161         ndr_print_ptr(ndr, "dll_name", r->dll_name);
13162         ndr->depth++;
13163         if (r->dll_name) {
13164                 ndr_print_string(ndr, "dll_name", r->dll_name);
13165         }
13166         ndr->depth--;
13167         ndr->depth--;
13168 }
13169
13170 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
13171 {
13172         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13173         if (ndr_flags & NDR_SCALARS) {
13174                 int level = ndr_push_get_switch_value(ndr, r);
13175                 switch (level) {
13176                         case 1: {
13177                                 NDR_CHECK(ndr_push_align(ndr, 4));
13178                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13179                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
13180                         break; }
13181
13182                         case 2: {
13183                                 NDR_CHECK(ndr_push_align(ndr, 4));
13184                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13185                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
13186                         break; }
13187
13188                         default: {
13189                         break; }
13190
13191                 }
13192         }
13193         if (ndr_flags & NDR_BUFFERS) {
13194                 int level = ndr_push_get_switch_value(ndr, r);
13195                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13196                 switch (level) {
13197                         case 1:
13198                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
13199                         break;
13200
13201                         case 2:
13202                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
13203                         break;
13204
13205                         default:
13206                         break;
13207
13208                 }
13209         }
13210         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13211         return NDR_ERR_SUCCESS;
13212 }
13213
13214 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
13215 {
13216         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13217         int level;
13218         level = ndr_pull_get_switch_value(ndr, r);
13219         if (ndr_flags & NDR_SCALARS) {
13220                 switch (level) {
13221                         case 1: {
13222                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13223                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13224                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
13225                         break; }
13226
13227                         case 2: {
13228                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13229                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13230                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
13231                         break; }
13232
13233                         default: {
13234                         break; }
13235
13236                 }
13237         }
13238         if (ndr_flags & NDR_BUFFERS) {
13239                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13240                 switch (level) {
13241                         case 1:
13242                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
13243                         break;
13244
13245                         case 2:
13246                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
13247                         break;
13248
13249                         default:
13250                         break;
13251
13252                 }
13253         }
13254         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13255         return NDR_ERR_SUCCESS;
13256 }
13257
13258 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
13259 {
13260         int level;
13261         level = ndr_print_get_switch_value(ndr, r);
13262         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
13263         switch (level) {
13264                 case 1:
13265                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
13266                 break;
13267
13268                 case 2:
13269                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
13270                 break;
13271
13272                 default:
13273                 break;
13274
13275         }
13276 }
13277
13278 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13279 {
13280         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13281         return NDR_ERR_SUCCESS;
13282 }
13283
13284 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13285 {
13286         uint32_t v;
13287         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13288         *r = v;
13289         return NDR_ERR_SUCCESS;
13290 }
13291
13292 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13293 {
13294         ndr_print_uint32(ndr, name, r);
13295         ndr->depth++;
13296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
13297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
13298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
13299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
13300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
13301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
13302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
13303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
13304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
13305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
13306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
13307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
13308         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
13309         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
13310         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
13311         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
13312         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
13313         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
13314         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
13315         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
13316         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
13317         ndr->depth--;
13318 }
13319
13320 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
13321 {
13322         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13323         return NDR_ERR_SUCCESS;
13324 }
13325
13326 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
13327 {
13328         uint16_t v;
13329         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13330         *r = v;
13331         return NDR_ERR_SUCCESS;
13332 }
13333
13334 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
13335 {
13336         const char *val = NULL;
13337
13338         switch (r) {
13339                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
13340                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
13341                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
13342                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
13343                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
13344                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
13345                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
13346                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
13347                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
13348                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
13349                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
13350                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
13351                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
13352                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
13353                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
13354                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
13355                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
13356                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
13357                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
13358                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
13359                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
13360                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
13361                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
13362                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
13363                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
13364                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
13365         }
13366         ndr_print_enum(ndr, name, "ENUM", val, r);
13367 }
13368
13369 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
13370 {
13371         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
13372         return NDR_ERR_SUCCESS;
13373 }
13374
13375 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
13376 {
13377         uint16_t v;
13378         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
13379         *r = v;
13380         return NDR_ERR_SUCCESS;
13381 }
13382
13383 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
13384 {
13385         const char *val = NULL;
13386
13387         switch (r) {
13388                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
13389                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
13390         }
13391         ndr_print_enum(ndr, name, "ENUM", val, r);
13392 }
13393
13394 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
13395 {
13396         uint32_t cntr_fields_1;
13397         if (ndr_flags & NDR_SCALARS) {
13398                 NDR_CHECK(ndr_push_align(ndr, 4));
13399                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13400                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
13401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
13402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
13403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
13405         }
13406         if (ndr_flags & NDR_BUFFERS) {
13407                 if (r->fields) {
13408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13409                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13410                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
13411                         }
13412                 }
13413         }
13414         return NDR_ERR_SUCCESS;
13415 }
13416
13417 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
13418 {
13419         uint32_t _ptr_fields;
13420         uint32_t cntr_fields_1;
13421         TALLOC_CTX *_mem_save_fields_0;
13422         TALLOC_CTX *_mem_save_fields_1;
13423         if (ndr_flags & NDR_SCALARS) {
13424                 NDR_CHECK(ndr_pull_align(ndr, 4));
13425                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13426                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
13427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
13428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
13429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13430                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
13431                 if (_ptr_fields) {
13432                         NDR_PULL_ALLOC(ndr, r->fields);
13433                 } else {
13434                         r->fields = NULL;
13435                 }
13436         }
13437         if (ndr_flags & NDR_BUFFERS) {
13438                 if (r->fields) {
13439                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
13440                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13441                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
13442                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
13443                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
13444                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13445                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13446                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
13447                         }
13448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
13449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
13450                 }
13451                 if (r->fields) {
13452                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
13453                 }
13454         }
13455         return NDR_ERR_SUCCESS;
13456 }
13457
13458 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
13459 {
13460         uint32_t cntr_fields_1;
13461         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
13462         ndr->depth++;
13463         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13464         ndr_print_uint16(ndr, "u1", r->u1);
13465         ndr_print_uint32(ndr, "u2", r->u2);
13466         ndr_print_uint32(ndr, "u3", r->u3);
13467         ndr_print_uint32(ndr, "count", r->count);
13468         ndr_print_ptr(ndr, "fields", r->fields);
13469         ndr->depth++;
13470         if (r->fields) {
13471                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
13472                 ndr->depth++;
13473                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
13474                         char *idx_1=NULL;
13475                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
13476                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
13477                                 free(idx_1);
13478                         }
13479                 }
13480                 ndr->depth--;
13481         }
13482         ndr->depth--;
13483         ndr->depth--;
13484 }
13485
13486 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13487 {
13488         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13489         return NDR_ERR_SUCCESS;
13490 }
13491
13492 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13493 {
13494         uint32_t v;
13495         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13496         *r = v;
13497         return NDR_ERR_SUCCESS;
13498 }
13499
13500 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13501 {
13502         ndr_print_uint32(ndr, name, r);
13503         ndr->depth++;
13504         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
13505         ndr->depth--;
13506 }
13507
13508 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
13509 {
13510         uint32_t cntr_types_1;
13511         if (ndr_flags & NDR_SCALARS) {
13512                 NDR_CHECK(ndr_push_align(ndr, 4));
13513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13514                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
13515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
13517         }
13518         if (ndr_flags & NDR_BUFFERS) {
13519                 if (r->types) {
13520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13521                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13522                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13523                         }
13524                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13525                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13526                         }
13527                 }
13528         }
13529         return NDR_ERR_SUCCESS;
13530 }
13531
13532 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
13533 {
13534         uint32_t _ptr_types;
13535         uint32_t cntr_types_1;
13536         TALLOC_CTX *_mem_save_types_0;
13537         TALLOC_CTX *_mem_save_types_1;
13538         if (ndr_flags & NDR_SCALARS) {
13539                 NDR_CHECK(ndr_pull_align(ndr, 4));
13540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13541                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
13542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
13544                 if (_ptr_types) {
13545                         NDR_PULL_ALLOC(ndr, r->types);
13546                 } else {
13547                         r->types = NULL;
13548                 }
13549         }
13550         if (ndr_flags & NDR_BUFFERS) {
13551                 if (r->types) {
13552                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
13553                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
13555                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
13556                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
13557                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13558                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13559                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13560                         }
13561                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13562                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13563                         }
13564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
13565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
13566                 }
13567                 if (r->types) {
13568                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
13569                 }
13570         }
13571         return NDR_ERR_SUCCESS;
13572 }
13573
13574 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
13575 {
13576         uint32_t cntr_types_1;
13577         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
13578         ndr->depth++;
13579         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13580         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
13581         ndr_print_uint32(ndr, "count", r->count);
13582         ndr_print_ptr(ndr, "types", r->types);
13583         ndr->depth++;
13584         if (r->types) {
13585                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
13586                 ndr->depth++;
13587                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
13588                         char *idx_1=NULL;
13589                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
13590                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
13591                                 free(idx_1);
13592                         }
13593                 }
13594                 ndr->depth--;
13595         }
13596         ndr->depth--;
13597         ndr->depth--;
13598 }
13599
13600 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
13601 {
13602         if (ndr_flags & NDR_SCALARS) {
13603                 NDR_CHECK(ndr_push_align(ndr, 4));
13604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
13606         }
13607         if (ndr_flags & NDR_BUFFERS) {
13608                 if (r->string) {
13609                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
13610                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
13611                 }
13612         }
13613         return NDR_ERR_SUCCESS;
13614 }
13615
13616 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
13617 {
13618         uint32_t _ptr_string;
13619         TALLOC_CTX *_mem_save_string_0;
13620         if (ndr_flags & NDR_SCALARS) {
13621                 NDR_CHECK(ndr_pull_align(ndr, 4));
13622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
13624                 if (_ptr_string) {
13625                         NDR_PULL_ALLOC(ndr, r->string);
13626                 } else {
13627                         r->string = NULL;
13628                 }
13629         }
13630         if (ndr_flags & NDR_BUFFERS) {
13631                 if (r->string) {
13632                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
13633                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
13634                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
13635                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
13636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
13637                 }
13638                 if (r->string) {
13639                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
13640                 }
13641         }
13642         return NDR_ERR_SUCCESS;
13643 }
13644
13645 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
13646 {
13647         ndr_print_struct(ndr, name, "spoolss_NotifyString");
13648         ndr->depth++;
13649         ndr_print_uint32(ndr, "size", r->size);
13650         ndr_print_ptr(ndr, "string", r->string);
13651         ndr->depth++;
13652         if (r->string) {
13653                 ndr_print_string(ndr, "string", r->string);
13654         }
13655         ndr->depth--;
13656         ndr->depth--;
13657 }
13658
13659 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
13660 {
13661         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13662         return NDR_ERR_SUCCESS;
13663 }
13664
13665 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
13666 {
13667         uint32_t v;
13668         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13669         *r = v;
13670         return NDR_ERR_SUCCESS;
13671 }
13672
13673 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
13674 {
13675         const char *val = NULL;
13676
13677         switch (r) {
13678                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
13679                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
13680                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
13681                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
13682                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
13683         }
13684         ndr_print_enum(ndr, name, "ENUM", val, r);
13685 }
13686
13687 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
13688 {
13689         if (ndr_flags & NDR_SCALARS) {
13690                 int level = ndr_push_get_switch_value(ndr, r);
13691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13692                 switch (level) {
13693                         case 1: {
13694                                 uint32_t cntr_integer_0;
13695                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13696                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
13697                                 }
13698                         break; }
13699
13700                         case 2: {
13701                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13702                         break; }
13703
13704                         case 3: {
13705                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
13706                         break; }
13707
13708                         case 4: {
13709                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13710                         break; }
13711
13712                         case 5: {
13713                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13714                         break; }
13715
13716                         default:
13717                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13718                 }
13719         }
13720         if (ndr_flags & NDR_BUFFERS) {
13721                 int level = ndr_push_get_switch_value(ndr, r);
13722                 switch (level) {
13723                         case 1:
13724                         break;
13725
13726                         case 2:
13727                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13728                         break;
13729
13730                         case 3:
13731                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
13732                         break;
13733
13734                         case 4:
13735                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13736                         break;
13737
13738                         case 5:
13739                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13740                         break;
13741
13742                         default:
13743                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13744                 }
13745         }
13746         return NDR_ERR_SUCCESS;
13747 }
13748
13749 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
13750 {
13751         int level;
13752         uint32_t _level;
13753         level = ndr_pull_get_switch_value(ndr, r);
13754         if (ndr_flags & NDR_SCALARS) {
13755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13756                 if (_level != level) {
13757                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13758                 }
13759                 switch (level) {
13760                         case 1: {
13761                                 uint32_t cntr_integer_0;
13762                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13763                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
13764                                 }
13765                         break; }
13766
13767                         case 2: {
13768                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13769                         break; }
13770
13771                         case 3: {
13772                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
13773                         break; }
13774
13775                         case 4: {
13776                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13777                         break; }
13778
13779                         case 5: {
13780                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13781                         break; }
13782
13783                         default:
13784                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13785                 }
13786         }
13787         if (ndr_flags & NDR_BUFFERS) {
13788                 switch (level) {
13789                         case 1:
13790                         break;
13791
13792                         case 2:
13793                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13794                         break;
13795
13796                         case 3:
13797                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
13798                         break;
13799
13800                         case 4:
13801                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13802                         break;
13803
13804                         case 5:
13805                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13806                         break;
13807
13808                         default:
13809                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13810                 }
13811         }
13812         return NDR_ERR_SUCCESS;
13813 }
13814
13815 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
13816 {
13817         int level;
13818         uint32_t cntr_integer_0;
13819         level = ndr_print_get_switch_value(ndr, r);
13820         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
13821         switch (level) {
13822                 case 1:
13823                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
13824                         ndr->depth++;
13825                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
13826                                 char *idx_0=NULL;
13827                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
13828                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
13829                                         free(idx_0);
13830                                 }
13831                         }
13832                         ndr->depth--;
13833                 break;
13834
13835                 case 2:
13836                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
13837                 break;
13838
13839                 case 3:
13840                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
13841                 break;
13842
13843                 case 4:
13844                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
13845                 break;
13846
13847                 case 5:
13848                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
13849                 break;
13850
13851                 default:
13852                         ndr_print_bad_level(ndr, name, level);
13853         }
13854 }
13855
13856 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
13857 {
13858         if (ndr_flags & NDR_SCALARS) {
13859                 NDR_CHECK(ndr_push_align(ndr, 4));
13860                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13861                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
13862                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
13863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
13864                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
13865                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13866         }
13867         if (ndr_flags & NDR_BUFFERS) {
13868                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13869         }
13870         return NDR_ERR_SUCCESS;
13871 }
13872
13873 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
13874 {
13875         if (ndr_flags & NDR_SCALARS) {
13876                 NDR_CHECK(ndr_pull_align(ndr, 4));
13877                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13878                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
13879                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
13880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
13881                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
13882                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13883         }
13884         if (ndr_flags & NDR_BUFFERS) {
13885                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13886         }
13887         return NDR_ERR_SUCCESS;
13888 }
13889
13890 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
13891 {
13892         ndr_print_struct(ndr, name, "spoolss_Notify");
13893         ndr->depth++;
13894         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13895         ndr_print_spoolss_Field(ndr, "field", r->field);
13896         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
13897         ndr_print_uint32(ndr, "job_id", r->job_id);
13898         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
13899         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
13900         ndr->depth--;
13901 }
13902
13903 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
13904 {
13905         uint32_t cntr_notifies_0;
13906         if (ndr_flags & NDR_SCALARS) {
13907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13908                 NDR_CHECK(ndr_push_align(ndr, 4));
13909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13912                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13913                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13914                 }
13915         }
13916         if (ndr_flags & NDR_BUFFERS) {
13917                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13918                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13919                 }
13920         }
13921         return NDR_ERR_SUCCESS;
13922 }
13923
13924 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
13925 {
13926         uint32_t cntr_notifies_0;
13927         TALLOC_CTX *_mem_save_notifies_0;
13928         if (ndr_flags & NDR_SCALARS) {
13929                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
13930                 NDR_CHECK(ndr_pull_align(ndr, 4));
13931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13934                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
13935                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13936                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13937                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13938                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13939                 }
13940                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13941                 if (r->notifies) {
13942                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
13943                 }
13944         }
13945         if (ndr_flags & NDR_BUFFERS) {
13946                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13947                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13948                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13949                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13950                 }
13951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13952         }
13953         return NDR_ERR_SUCCESS;
13954 }
13955
13956 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
13957 {
13958         uint32_t cntr_notifies_0;
13959         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
13960         ndr->depth++;
13961         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13962         ndr_print_uint32(ndr, "flags", r->flags);
13963         ndr_print_uint32(ndr, "count", r->count);
13964         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
13965         ndr->depth++;
13966         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
13967                 char *idx_0=NULL;
13968                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
13969                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
13970                         free(idx_0);
13971                 }
13972         }
13973         ndr->depth--;
13974         ndr->depth--;
13975 }
13976
13977 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
13978 {
13979         if (ndr_flags & NDR_SCALARS) {
13980                 int level = ndr_push_get_switch_value(ndr, r);
13981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13982                 switch (level) {
13983                         case 0: {
13984                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
13985                         break; }
13986
13987                         default:
13988                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13989                 }
13990         }
13991         if (ndr_flags & NDR_BUFFERS) {
13992                 int level = ndr_push_get_switch_value(ndr, r);
13993                 switch (level) {
13994                         case 0:
13995                                 if (r->info0) {
13996                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13997                                 }
13998                         break;
13999
14000                         default:
14001                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14002                 }
14003         }
14004         return NDR_ERR_SUCCESS;
14005 }
14006
14007 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
14008 {
14009         int level;
14010         uint32_t _level;
14011         TALLOC_CTX *_mem_save_info0_0;
14012         level = ndr_pull_get_switch_value(ndr, r);
14013         if (ndr_flags & NDR_SCALARS) {
14014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14015                 if (_level != level) {
14016                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14017                 }
14018                 switch (level) {
14019                         case 0: {
14020                                 uint32_t _ptr_info0;
14021                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
14022                                 if (_ptr_info0) {
14023                                         NDR_PULL_ALLOC(ndr, r->info0);
14024                                 } else {
14025                                         r->info0 = NULL;
14026                                 }
14027                         break; }
14028
14029                         default:
14030                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14031                 }
14032         }
14033         if (ndr_flags & NDR_BUFFERS) {
14034                 switch (level) {
14035                         case 0:
14036                                 if (r->info0) {
14037                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
14038                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
14039                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
14040                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
14041                                 }
14042                         break;
14043
14044                         default:
14045                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14046                 }
14047         }
14048         return NDR_ERR_SUCCESS;
14049 }
14050
14051 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
14052 {
14053         int level;
14054         level = ndr_print_get_switch_value(ndr, r);
14055         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
14056         switch (level) {
14057                 case 0:
14058                         ndr_print_ptr(ndr, "info0", r->info0);
14059                         ndr->depth++;
14060                         if (r->info0) {
14061                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
14062                         }
14063                         ndr->depth--;
14064                 break;
14065
14066                 default:
14067                         ndr_print_bad_level(ndr, name, level);
14068         }
14069 }
14070
14071 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14072 {
14073         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14074         return NDR_ERR_SUCCESS;
14075 }
14076
14077 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14078 {
14079         uint32_t v;
14080         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14081         *r = v;
14082         return NDR_ERR_SUCCESS;
14083 }
14084
14085 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14086 {
14087         ndr_print_uint32(ndr, name, r);
14088         ndr->depth++;
14089         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
14090         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
14091         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
14092         ndr->depth--;
14093 }
14094
14095 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
14096 {
14097         if (ndr_flags & NDR_SCALARS) {
14098                 NDR_CHECK(ndr_push_align(ndr, 4));
14099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
14100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
14101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
14102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14103                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
14104                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
14105                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
14106         }
14107         if (ndr_flags & NDR_BUFFERS) {
14108                 if (r->client) {
14109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14112                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14113                 }
14114                 if (r->user) {
14115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14118                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14119                 }
14120         }
14121         return NDR_ERR_SUCCESS;
14122 }
14123
14124 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
14125 {
14126         uint32_t _ptr_client;
14127         TALLOC_CTX *_mem_save_client_0;
14128         uint32_t _ptr_user;
14129         TALLOC_CTX *_mem_save_user_0;
14130         if (ndr_flags & NDR_SCALARS) {
14131                 NDR_CHECK(ndr_pull_align(ndr, 4));
14132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14134                 if (_ptr_client) {
14135                         NDR_PULL_ALLOC(ndr, r->client);
14136                 } else {
14137                         r->client = NULL;
14138                 }
14139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14140                 if (_ptr_user) {
14141                         NDR_PULL_ALLOC(ndr, r->user);
14142                 } else {
14143                         r->user = NULL;
14144                 }
14145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14146                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
14147                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
14148                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
14149         }
14150         if (ndr_flags & NDR_BUFFERS) {
14151                 if (r->client) {
14152                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14153                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
14154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
14155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
14156                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
14157                                 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));
14158                         }
14159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
14160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
14161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14162                 }
14163                 if (r->user) {
14164                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14165                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
14166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
14167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
14168                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
14169                                 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));
14170                         }
14171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
14172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
14173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14174                 }
14175         }
14176         return NDR_ERR_SUCCESS;
14177 }
14178
14179 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
14180 {
14181         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
14182         ndr->depth++;
14183         ndr_print_uint32(ndr, "size", r->size);
14184         ndr_print_ptr(ndr, "client", r->client);
14185         ndr->depth++;
14186         if (r->client) {
14187                 ndr_print_string(ndr, "client", r->client);
14188         }
14189         ndr->depth--;
14190         ndr_print_ptr(ndr, "user", r->user);
14191         ndr->depth++;
14192         if (r->user) {
14193                 ndr_print_string(ndr, "user", r->user);
14194         }
14195         ndr->depth--;
14196         ndr_print_uint32(ndr, "build", r->build);
14197         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
14198         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
14199         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
14200         ndr->depth--;
14201 }
14202
14203 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
14204 {
14205         if (ndr_flags & NDR_SCALARS) {
14206                 NDR_CHECK(ndr_push_align(ndr, 4));
14207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
14208         }
14209         if (ndr_flags & NDR_BUFFERS) {
14210         }
14211         return NDR_ERR_SUCCESS;
14212 }
14213
14214 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
14215 {
14216         if (ndr_flags & NDR_SCALARS) {
14217                 NDR_CHECK(ndr_pull_align(ndr, 4));
14218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
14219         }
14220         if (ndr_flags & NDR_BUFFERS) {
14221         }
14222         return NDR_ERR_SUCCESS;
14223 }
14224
14225 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
14226 {
14227         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
14228         ndr->depth++;
14229         ndr_print_uint32(ndr, "not_used", r->not_used);
14230         ndr->depth--;
14231 }
14232
14233 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
14234 {
14235         if (ndr_flags & NDR_SCALARS) {
14236                 NDR_CHECK(ndr_push_align(ndr, 4));
14237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
14238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
14239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
14240                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
14241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
14242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14243                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
14244                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
14245                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
14246                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
14247         }
14248         if (ndr_flags & NDR_BUFFERS) {
14249                 if (r->client) {
14250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14252                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
14253                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14254                 }
14255                 if (r->user) {
14256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14257                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14258                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
14259                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14260                 }
14261         }
14262         return NDR_ERR_SUCCESS;
14263 }
14264
14265 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
14266 {
14267         uint32_t _ptr_client;
14268         TALLOC_CTX *_mem_save_client_0;
14269         uint32_t _ptr_user;
14270         TALLOC_CTX *_mem_save_user_0;
14271         if (ndr_flags & NDR_SCALARS) {
14272                 NDR_CHECK(ndr_pull_align(ndr, 4));
14273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
14275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
14276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14277                 if (_ptr_client) {
14278                         NDR_PULL_ALLOC(ndr, r->client);
14279                 } else {
14280                         r->client = NULL;
14281                 }
14282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14283                 if (_ptr_user) {
14284                         NDR_PULL_ALLOC(ndr, r->user);
14285                 } else {
14286                         r->user = NULL;
14287                 }
14288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14289                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
14290                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
14291                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
14292                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
14293         }
14294         if (ndr_flags & NDR_BUFFERS) {
14295                 if (r->client) {
14296                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14297                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
14298                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
14299                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
14300                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
14301                                 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));
14302                         }
14303                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
14304                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
14305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14306                 }
14307                 if (r->user) {
14308                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14309                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
14310                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
14311                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
14312                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
14313                                 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));
14314                         }
14315                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
14316                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
14317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14318                 }
14319         }
14320         return NDR_ERR_SUCCESS;
14321 }
14322
14323 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
14324 {
14325         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
14326         ndr->depth++;
14327         ndr_print_uint32(ndr, "size", r->size);
14328         ndr_print_uint32(ndr, "flags", r->flags);
14329         ndr_print_uint32(ndr, "size2", r->size2);
14330         ndr_print_ptr(ndr, "client", r->client);
14331         ndr->depth++;
14332         if (r->client) {
14333                 ndr_print_string(ndr, "client", r->client);
14334         }
14335         ndr->depth--;
14336         ndr_print_ptr(ndr, "user", r->user);
14337         ndr->depth++;
14338         if (r->user) {
14339                 ndr_print_string(ndr, "user", r->user);
14340         }
14341         ndr->depth--;
14342         ndr_print_uint32(ndr, "build", r->build);
14343         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
14344         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
14345         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
14346         ndr_print_udlong(ndr, "reserved", r->reserved);
14347         ndr->depth--;
14348 }
14349
14350 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
14351 {
14352         if (ndr_flags & NDR_SCALARS) {
14353                 int level = ndr_push_get_switch_value(ndr, r);
14354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14355                 switch (level) {
14356                         case 1: {
14357                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
14358                         break; }
14359
14360                         case 2: {
14361                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
14362                         break; }
14363
14364                         case 3: {
14365                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
14366                         break; }
14367
14368                         default:
14369                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14370                 }
14371         }
14372         if (ndr_flags & NDR_BUFFERS) {
14373                 int level = ndr_push_get_switch_value(ndr, r);
14374                 switch (level) {
14375                         case 1:
14376                                 if (r->level1) {
14377                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14378                                 }
14379                         break;
14380
14381                         case 2:
14382                                 if (r->level2) {
14383                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14384                                 }
14385                         break;
14386
14387                         case 3:
14388                                 if (r->level3) {
14389                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14390                                 }
14391                         break;
14392
14393                         default:
14394                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14395                 }
14396         }
14397         return NDR_ERR_SUCCESS;
14398 }
14399
14400 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
14401 {
14402         int level;
14403         uint32_t _level;
14404         TALLOC_CTX *_mem_save_level1_0;
14405         TALLOC_CTX *_mem_save_level2_0;
14406         TALLOC_CTX *_mem_save_level3_0;
14407         level = ndr_pull_get_switch_value(ndr, r);
14408         if (ndr_flags & NDR_SCALARS) {
14409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14410                 if (_level != level) {
14411                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14412                 }
14413                 switch (level) {
14414                         case 1: {
14415                                 uint32_t _ptr_level1;
14416                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
14417                                 if (_ptr_level1) {
14418                                         NDR_PULL_ALLOC(ndr, r->level1);
14419                                 } else {
14420                                         r->level1 = NULL;
14421                                 }
14422                         break; }
14423
14424                         case 2: {
14425                                 uint32_t _ptr_level2;
14426                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
14427                                 if (_ptr_level2) {
14428                                         NDR_PULL_ALLOC(ndr, r->level2);
14429                                 } else {
14430                                         r->level2 = NULL;
14431                                 }
14432                         break; }
14433
14434                         case 3: {
14435                                 uint32_t _ptr_level3;
14436                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
14437                                 if (_ptr_level3) {
14438                                         NDR_PULL_ALLOC(ndr, r->level3);
14439                                 } else {
14440                                         r->level3 = NULL;
14441                                 }
14442                         break; }
14443
14444                         default:
14445                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14446                 }
14447         }
14448         if (ndr_flags & NDR_BUFFERS) {
14449                 switch (level) {
14450                         case 1:
14451                                 if (r->level1) {
14452                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14453                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
14454                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14455                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
14456                                 }
14457                         break;
14458
14459                         case 2:
14460                                 if (r->level2) {
14461                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
14462                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
14463                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14464                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
14465                                 }
14466                         break;
14467
14468                         case 3:
14469                                 if (r->level3) {
14470                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
14471                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
14472                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14473                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
14474                                 }
14475                         break;
14476
14477                         default:
14478                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14479                 }
14480         }
14481         return NDR_ERR_SUCCESS;
14482 }
14483
14484 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
14485 {
14486         int level;
14487         level = ndr_print_get_switch_value(ndr, r);
14488         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
14489         switch (level) {
14490                 case 1:
14491                         ndr_print_ptr(ndr, "level1", r->level1);
14492                         ndr->depth++;
14493                         if (r->level1) {
14494                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
14495                         }
14496                         ndr->depth--;
14497                 break;
14498
14499                 case 2:
14500                         ndr_print_ptr(ndr, "level2", r->level2);
14501                         ndr->depth++;
14502                         if (r->level2) {
14503                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
14504                         }
14505                         ndr->depth--;
14506                 break;
14507
14508                 case 3:
14509                         ndr_print_ptr(ndr, "level3", r->level3);
14510                         ndr->depth++;
14511                         if (r->level3) {
14512                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
14513                         }
14514                         ndr->depth--;
14515                 break;
14516
14517                 default:
14518                         ndr_print_bad_level(ndr, name, level);
14519         }
14520 }
14521
14522 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
14523 {
14524         if (ndr_flags & NDR_SCALARS) {
14525                 NDR_CHECK(ndr_push_align(ndr, 4));
14526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
14527                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
14528                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14529         }
14530         if (ndr_flags & NDR_BUFFERS) {
14531                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14532         }
14533         return NDR_ERR_SUCCESS;
14534 }
14535
14536 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
14537 {
14538         if (ndr_flags & NDR_SCALARS) {
14539                 NDR_CHECK(ndr_pull_align(ndr, 4));
14540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
14541                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
14542                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14543         }
14544         if (ndr_flags & NDR_BUFFERS) {
14545                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14546         }
14547         return NDR_ERR_SUCCESS;
14548 }
14549
14550 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
14551 {
14552         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
14553         ndr->depth++;
14554         ndr_print_uint32(ndr, "level", r->level);
14555         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
14556         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
14557         ndr->depth--;
14558 }
14559
14560 static enum ndr_err_code ndr_push_spoolss_AccessRights(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_AccessRights(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_AccessRights(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), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
14579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
14580         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
14581         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
14582         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
14583         ndr->depth--;
14584 }
14585
14586 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14587 {
14588         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14589         return NDR_ERR_SUCCESS;
14590 }
14591
14592 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14593 {
14594         uint32_t v;
14595         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14596         *r = v;
14597         return NDR_ERR_SUCCESS;
14598 }
14599
14600 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14601 {
14602         ndr_print_uint32(ndr, name, r);
14603         ndr->depth++;
14604         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
14605         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
14606         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
14607         ndr->depth--;
14608 }
14609
14610 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
14611 {
14612         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14613         return NDR_ERR_SUCCESS;
14614 }
14615
14616 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
14617 {
14618         uint32_t v;
14619         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14620         *r = v;
14621         return NDR_ERR_SUCCESS;
14622 }
14623
14624 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
14625 {
14626         const char *val = NULL;
14627
14628         switch (r) {
14629                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
14630                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
14631         }
14632         ndr_print_enum(ndr, name, "ENUM", val, r);
14633 }
14634
14635 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
14636 {
14637         if (ndr_flags & NDR_SCALARS) {
14638                 NDR_CHECK(ndr_push_align(ndr, 4));
14639                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
14641                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14644                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14645                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14647                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14648                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14649                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14650                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14654         }
14655         if (ndr_flags & NDR_BUFFERS) {
14656         }
14657         return NDR_ERR_SUCCESS;
14658 }
14659
14660 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
14661 {
14662         if (ndr_flags & NDR_SCALARS) {
14663                 NDR_CHECK(ndr_pull_align(ndr, 4));
14664                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14666                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14669                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14670                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14672                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14673                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14674                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14675                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14679         }
14680         if (ndr_flags & NDR_BUFFERS) {
14681         }
14682         return NDR_ERR_SUCCESS;
14683 }
14684
14685 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
14686 {
14687         ndr_print_struct(ndr, name, "spoolss_PortData1");
14688         ndr->depth++;
14689         ndr_print_string(ndr, "portname", r->portname);
14690         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
14691         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14692         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14693         ndr_print_uint32(ndr, "reserved", r->reserved);
14694         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14695         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14696         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14697         ndr_print_string(ndr, "queue", r->queue);
14698         ndr_print_string(ndr, "ip_address", r->ip_address);
14699         ndr_print_string(ndr, "hardware_address", r->hardware_address);
14700         ndr_print_string(ndr, "device_type", r->device_type);
14701         ndr_print_uint32(ndr, "port_number", r->port_number);
14702         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14703         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14704         ndr->depth--;
14705 }
14706
14707 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
14708 {
14709         if (ndr_flags & NDR_SCALARS) {
14710                 NDR_CHECK(ndr_push_align(ndr, 4));
14711                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
14713                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14716                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14717                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14719                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14720                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
14725         }
14726         if (ndr_flags & NDR_BUFFERS) {
14727         }
14728         return NDR_ERR_SUCCESS;
14729 }
14730
14731 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
14732 {
14733         if (ndr_flags & NDR_SCALARS) {
14734                 NDR_CHECK(ndr_pull_align(ndr, 4));
14735                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14737                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14740                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14741                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14743                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14744                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
14749         }
14750         if (ndr_flags & NDR_BUFFERS) {
14751         }
14752         return NDR_ERR_SUCCESS;
14753 }
14754
14755 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
14756 {
14757         ndr_print_struct(ndr, name, "spoolss_PortData2");
14758         ndr->depth++;
14759         ndr_print_string(ndr, "portname", r->portname);
14760         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
14761         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14762         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14763         ndr_print_uint32(ndr, "reserved", r->reserved);
14764         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14765         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14766         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14767         ndr_print_string(ndr, "queue", r->queue);
14768         ndr_print_string(ndr, "device_type", r->device_type);
14769         ndr_print_uint32(ndr, "port_number", r->port_number);
14770         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14771         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14772         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
14773         ndr->depth--;
14774 }
14775
14776 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
14777 {
14778         if (ndr_flags & NDR_SCALARS) {
14779                 NDR_CHECK(ndr_push_align(ndr, 4));
14780                 {
14781                         uint32_t _flags_save_string = ndr->flags;
14782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14783                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
14784                         ndr->flags = _flags_save_string;
14785                 }
14786         }
14787         if (ndr_flags & NDR_BUFFERS) {
14788         }
14789         return NDR_ERR_SUCCESS;
14790 }
14791
14792 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
14793 {
14794         if (ndr_flags & NDR_SCALARS) {
14795                 NDR_CHECK(ndr_pull_align(ndr, 4));
14796                 {
14797                         uint32_t _flags_save_string = ndr->flags;
14798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14799                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
14800                         ndr->flags = _flags_save_string;
14801                 }
14802         }
14803         if (ndr_flags & NDR_BUFFERS) {
14804         }
14805         return NDR_ERR_SUCCESS;
14806 }
14807
14808 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
14809 {
14810         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
14811         ndr->depth++;
14812         ndr_print_string(ndr, "dll_name", r->dll_name);
14813         ndr->depth--;
14814 }
14815
14816 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14817 {
14818         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14819         return NDR_ERR_SUCCESS;
14820 }
14821
14822 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14823 {
14824         uint32_t v;
14825         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14826         *r = v;
14827         return NDR_ERR_SUCCESS;
14828 }
14829
14830 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14831 {
14832         ndr_print_uint32(ndr, name, r);
14833         ndr->depth++;
14834         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
14835         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
14836         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
14837         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
14838         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
14839         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
14840         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
14841         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
14842         ndr->depth--;
14843 }
14844
14845 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
14846 {
14847         if (flags & NDR_IN) {
14848                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
14849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14850                 if (r->in.server) {
14851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14854                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14855                 }
14856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14858                 if (r->in.buffer) {
14859                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14860                 }
14861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14862         }
14863         if (flags & NDR_OUT) {
14864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14865                 if (r->out.info) {
14866                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
14867                 }
14868                 if (r->out.needed == NULL) {
14869                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14870                 }
14871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14872                 if (r->out.count == NULL) {
14873                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14874                 }
14875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
14876                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14877         }
14878         return NDR_ERR_SUCCESS;
14879 }
14880
14881 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
14882 {
14883         uint32_t _ptr_server;
14884         uint32_t _ptr_buffer;
14885         uint32_t _ptr_info;
14886         TALLOC_CTX *_mem_save_server_0;
14887         TALLOC_CTX *_mem_save_buffer_0;
14888         TALLOC_CTX *_mem_save_info_0;
14889         TALLOC_CTX *_mem_save_needed_0;
14890         TALLOC_CTX *_mem_save_count_0;
14891         if (flags & NDR_IN) {
14892                 ZERO_STRUCT(r->out);
14893
14894                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
14895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14896                 if (_ptr_server) {
14897                         NDR_PULL_ALLOC(ndr, r->in.server);
14898                 } else {
14899                         r->in.server = NULL;
14900                 }
14901                 if (r->in.server) {
14902                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14903                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14904                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14905                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14906                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14907                                 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));
14908                         }
14909                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14910                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14912                 }
14913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14915                 if (_ptr_buffer) {
14916                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14917                 } else {
14918                         r->in.buffer = NULL;
14919                 }
14920                 if (r->in.buffer) {
14921                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14922                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14923                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14925                 }
14926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14927                 NDR_PULL_ALLOC(ndr, r->out.needed);
14928                 ZERO_STRUCTP(r->out.needed);
14929                 NDR_PULL_ALLOC(ndr, r->out.count);
14930                 ZERO_STRUCTP(r->out.count);
14931         }
14932         if (flags & NDR_OUT) {
14933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14934                 if (_ptr_info) {
14935                         NDR_PULL_ALLOC(ndr, r->out.info);
14936                 } else {
14937                         r->out.info = NULL;
14938                 }
14939                 if (r->out.info) {
14940                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14941                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14942                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
14943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14944                 }
14945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14946                         NDR_PULL_ALLOC(ndr, r->out.needed);
14947                 }
14948                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14949                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14952                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14953                         NDR_PULL_ALLOC(ndr, r->out.count);
14954                 }
14955                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
14956                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
14957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
14958                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
14959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14960         }
14961         return NDR_ERR_SUCCESS;
14962 }
14963
14964 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
14965 {
14966         uint32_t cntr_info_0;
14967         if (flags & NDR_IN) {
14968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
14970         }
14971         if (flags & NDR_OUT) {
14972                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14973                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14974                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14975                 }
14976                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14977                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14978                 }
14979         }
14980         return NDR_ERR_SUCCESS;
14981 }
14982
14983 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
14984 {
14985         uint32_t cntr_info_0;
14986         TALLOC_CTX *_mem_save_info_0;
14987         if (flags & NDR_IN) {
14988                 ZERO_STRUCT(r->out);
14989
14990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
14992         }
14993         if (flags & NDR_OUT) {
14994                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
14995                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14997                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14998                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14999                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15000                 }
15001                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15002                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15003                 }
15004                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15005         }
15006         return NDR_ERR_SUCCESS;
15007 }
15008
15009 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
15010 {
15011         uint32_t cntr_info_1;
15012         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
15013         ndr->depth++;
15014         if (flags & NDR_SET_VALUES) {
15015                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15016         }
15017         if (flags & NDR_IN) {
15018                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
15019                 ndr->depth++;
15020                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
15021                 ndr_print_ptr(ndr, "server", r->in.server);
15022                 ndr->depth++;
15023                 if (r->in.server) {
15024                         ndr_print_string(ndr, "server", r->in.server);
15025                 }
15026                 ndr->depth--;
15027                 ndr_print_uint32(ndr, "level", r->in.level);
15028                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15029                 ndr->depth++;
15030                 if (r->in.buffer) {
15031                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15032                 }
15033                 ndr->depth--;
15034                 ndr_print_uint32(ndr, "offered", r->in.offered);
15035                 ndr->depth--;
15036         }
15037         if (flags & NDR_OUT) {
15038                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
15039                 ndr->depth++;
15040                 ndr_print_ptr(ndr, "count", r->out.count);
15041                 ndr->depth++;
15042                 ndr_print_uint32(ndr, "count", *r->out.count);
15043                 ndr->depth--;
15044                 ndr_print_ptr(ndr, "info", r->out.info);
15045                 ndr->depth++;
15046                 if (r->out.info) {
15047                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15048                         ndr->depth++;
15049                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15050                                 char *idx_1=NULL;
15051                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15052                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15053                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
15054                                         free(idx_1);
15055                                 }
15056                         }
15057                         ndr->depth--;
15058                 }
15059                 ndr->depth--;
15060                 ndr_print_ptr(ndr, "needed", r->out.needed);
15061                 ndr->depth++;
15062                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15063                 ndr->depth--;
15064                 ndr_print_WERROR(ndr, "result", r->out.result);
15065                 ndr->depth--;
15066         }
15067         ndr->depth--;
15068 }
15069
15070 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
15071 {
15072         if (flags & NDR_IN) {
15073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
15074                 if (r->in.printername) {
15075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
15076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
15078                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15079                 }
15080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
15081                 if (r->in.datatype) {
15082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
15083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
15085                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15086                 }
15087                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15088                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
15089         }
15090         if (flags & NDR_OUT) {
15091                 if (r->out.handle == NULL) {
15092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15093                 }
15094                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15095                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15096         }
15097         return NDR_ERR_SUCCESS;
15098 }
15099
15100 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
15101 {
15102         uint32_t _ptr_printername;
15103         uint32_t _ptr_datatype;
15104         TALLOC_CTX *_mem_save_printername_0;
15105         TALLOC_CTX *_mem_save_datatype_0;
15106         TALLOC_CTX *_mem_save_handle_0;
15107         if (flags & NDR_IN) {
15108                 ZERO_STRUCT(r->out);
15109
15110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
15111                 if (_ptr_printername) {
15112                         NDR_PULL_ALLOC(ndr, r->in.printername);
15113                 } else {
15114                         r->in.printername = NULL;
15115                 }
15116                 if (r->in.printername) {
15117                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
15118                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
15119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
15120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
15121                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
15122                                 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));
15123                         }
15124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
15125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
15126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
15127                 }
15128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15129                 if (_ptr_datatype) {
15130                         NDR_PULL_ALLOC(ndr, r->in.datatype);
15131                 } else {
15132                         r->in.datatype = NULL;
15133                 }
15134                 if (r->in.datatype) {
15135                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15136                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
15137                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
15138                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
15139                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
15140                                 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));
15141                         }
15142                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
15143                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
15144                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15145                 }
15146                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15147                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
15148                 NDR_PULL_ALLOC(ndr, r->out.handle);
15149                 ZERO_STRUCTP(r->out.handle);
15150         }
15151         if (flags & NDR_OUT) {
15152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15153                         NDR_PULL_ALLOC(ndr, r->out.handle);
15154                 }
15155                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15156                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
15157                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15159                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15160         }
15161         return NDR_ERR_SUCCESS;
15162 }
15163
15164 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
15165 {
15166         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
15167         ndr->depth++;
15168         if (flags & NDR_SET_VALUES) {
15169                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15170         }
15171         if (flags & NDR_IN) {
15172                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
15173                 ndr->depth++;
15174                 ndr_print_ptr(ndr, "printername", r->in.printername);
15175                 ndr->depth++;
15176                 if (r->in.printername) {
15177                         ndr_print_string(ndr, "printername", r->in.printername);
15178                 }
15179                 ndr->depth--;
15180                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
15181                 ndr->depth++;
15182                 if (r->in.datatype) {
15183                         ndr_print_string(ndr, "datatype", r->in.datatype);
15184                 }
15185                 ndr->depth--;
15186                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
15187                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
15188                 ndr->depth--;
15189         }
15190         if (flags & NDR_OUT) {
15191                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
15192                 ndr->depth++;
15193                 ndr_print_ptr(ndr, "handle", r->out.handle);
15194                 ndr->depth++;
15195                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
15196                 ndr->depth--;
15197                 ndr_print_WERROR(ndr, "result", r->out.result);
15198                 ndr->depth--;
15199         }
15200         ndr->depth--;
15201 }
15202
15203 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
15204 {
15205         if (flags & NDR_IN) {
15206                 if (r->in.handle == NULL) {
15207                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15208                 }
15209                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
15211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
15212                 if (r->in.ctr) {
15213                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
15214                 }
15215                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
15216         }
15217         if (flags & NDR_OUT) {
15218                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15219         }
15220         return NDR_ERR_SUCCESS;
15221 }
15222
15223 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
15224 {
15225         uint32_t _ptr_ctr;
15226         TALLOC_CTX *_mem_save_handle_0;
15227         TALLOC_CTX *_mem_save_ctr_0;
15228         if (flags & NDR_IN) {
15229                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15230                         NDR_PULL_ALLOC(ndr, r->in.handle);
15231                 }
15232                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15233                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15234                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15235                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
15237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
15238                 if (_ptr_ctr) {
15239                         NDR_PULL_ALLOC(ndr, r->in.ctr);
15240                 } else {
15241                         r->in.ctr = NULL;
15242                 }
15243                 if (r->in.ctr) {
15244                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15245                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
15246                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
15247                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
15248                 }
15249                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
15250         }
15251         if (flags & NDR_OUT) {
15252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15253         }
15254         return NDR_ERR_SUCCESS;
15255 }
15256
15257 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
15258 {
15259         ndr_print_struct(ndr, name, "spoolss_SetJob");
15260         ndr->depth++;
15261         if (flags & NDR_SET_VALUES) {
15262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15263         }
15264         if (flags & NDR_IN) {
15265                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
15266                 ndr->depth++;
15267                 ndr_print_ptr(ndr, "handle", r->in.handle);
15268                 ndr->depth++;
15269                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15270                 ndr->depth--;
15271                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15272                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
15273                 ndr->depth++;
15274                 if (r->in.ctr) {
15275                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
15276                 }
15277                 ndr->depth--;
15278                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
15279                 ndr->depth--;
15280         }
15281         if (flags & NDR_OUT) {
15282                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
15283                 ndr->depth++;
15284                 ndr_print_WERROR(ndr, "result", r->out.result);
15285                 ndr->depth--;
15286         }
15287         ndr->depth--;
15288 }
15289
15290 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
15291 {
15292         if (flags & NDR_IN) {
15293                 if (r->in.handle == NULL) {
15294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15295                 }
15296                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
15298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15299                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15300                 if (r->in.buffer) {
15301                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15302                 }
15303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15304         }
15305         if (flags & NDR_OUT) {
15306                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15307                 if (r->out.info) {
15308                         {
15309                                 struct ndr_push *_ndr_info;
15310                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15311                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15312                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15313                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15314                         }
15315                 }
15316                 if (r->out.needed == NULL) {
15317                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15318                 }
15319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15320                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15321         }
15322         return NDR_ERR_SUCCESS;
15323 }
15324
15325 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
15326 {
15327         uint32_t _ptr_buffer;
15328         uint32_t _ptr_info;
15329         TALLOC_CTX *_mem_save_handle_0;
15330         TALLOC_CTX *_mem_save_buffer_0;
15331         TALLOC_CTX *_mem_save_info_0;
15332         TALLOC_CTX *_mem_save_needed_0;
15333         if (flags & NDR_IN) {
15334                 ZERO_STRUCT(r->out);
15335
15336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15337                         NDR_PULL_ALLOC(ndr, r->in.handle);
15338                 }
15339                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15341                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
15344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15346                 if (_ptr_buffer) {
15347                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15348                 } else {
15349                         r->in.buffer = NULL;
15350                 }
15351                 if (r->in.buffer) {
15352                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15353                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15354                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15356                 }
15357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15358                 NDR_PULL_ALLOC(ndr, r->out.needed);
15359                 ZERO_STRUCTP(r->out.needed);
15360         }
15361         if (flags & NDR_OUT) {
15362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15363                 if (_ptr_info) {
15364                         NDR_PULL_ALLOC(ndr, r->out.info);
15365                 } else {
15366                         r->out.info = NULL;
15367                 }
15368                 if (r->out.info) {
15369                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15370                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15371                         {
15372                                 struct ndr_pull *_ndr_info;
15373                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15374                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15375                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15376                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15377                         }
15378                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15379                 }
15380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15381                         NDR_PULL_ALLOC(ndr, r->out.needed);
15382                 }
15383                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15384                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15388         }
15389         return NDR_ERR_SUCCESS;
15390 }
15391
15392 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
15393 {
15394         ndr_print_struct(ndr, name, "spoolss_GetJob");
15395         ndr->depth++;
15396         if (flags & NDR_SET_VALUES) {
15397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15398         }
15399         if (flags & NDR_IN) {
15400                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
15401                 ndr->depth++;
15402                 ndr_print_ptr(ndr, "handle", r->in.handle);
15403                 ndr->depth++;
15404                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15405                 ndr->depth--;
15406                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15407                 ndr_print_uint32(ndr, "level", r->in.level);
15408                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15409                 ndr->depth++;
15410                 if (r->in.buffer) {
15411                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15412                 }
15413                 ndr->depth--;
15414                 ndr_print_uint32(ndr, "offered", r->in.offered);
15415                 ndr->depth--;
15416         }
15417         if (flags & NDR_OUT) {
15418                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
15419                 ndr->depth++;
15420                 ndr_print_ptr(ndr, "info", r->out.info);
15421                 ndr->depth++;
15422                 if (r->out.info) {
15423                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15424                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
15425                 }
15426                 ndr->depth--;
15427                 ndr_print_ptr(ndr, "needed", r->out.needed);
15428                 ndr->depth++;
15429                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15430                 ndr->depth--;
15431                 ndr_print_WERROR(ndr, "result", r->out.result);
15432                 ndr->depth--;
15433         }
15434         ndr->depth--;
15435 }
15436
15437 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
15438 {
15439         if (flags & NDR_IN) {
15440                 if (r->in.handle == NULL) {
15441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15442                 }
15443                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
15445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
15446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15448                 if (r->in.buffer) {
15449                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15450                 }
15451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15452         }
15453         if (flags & NDR_OUT) {
15454                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15455                 if (r->out.info) {
15456                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15457                 }
15458                 if (r->out.needed == NULL) {
15459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15460                 }
15461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15462                 if (r->out.count == NULL) {
15463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15464                 }
15465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15467         }
15468         return NDR_ERR_SUCCESS;
15469 }
15470
15471 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
15472 {
15473         uint32_t _ptr_buffer;
15474         uint32_t _ptr_info;
15475         TALLOC_CTX *_mem_save_handle_0;
15476         TALLOC_CTX *_mem_save_buffer_0;
15477         TALLOC_CTX *_mem_save_info_0;
15478         TALLOC_CTX *_mem_save_needed_0;
15479         TALLOC_CTX *_mem_save_count_0;
15480         if (flags & NDR_IN) {
15481                 ZERO_STRUCT(r->out);
15482
15483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15484                         NDR_PULL_ALLOC(ndr, r->in.handle);
15485                 }
15486                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15487                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15488                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
15491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
15492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15494                 if (_ptr_buffer) {
15495                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15496                 } else {
15497                         r->in.buffer = NULL;
15498                 }
15499                 if (r->in.buffer) {
15500                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15501                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15502                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15504                 }
15505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15506                 NDR_PULL_ALLOC(ndr, r->out.needed);
15507                 ZERO_STRUCTP(r->out.needed);
15508                 NDR_PULL_ALLOC(ndr, r->out.count);
15509                 ZERO_STRUCTP(r->out.count);
15510         }
15511         if (flags & NDR_OUT) {
15512                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15513                 if (_ptr_info) {
15514                         NDR_PULL_ALLOC(ndr, r->out.info);
15515                 } else {
15516                         r->out.info = NULL;
15517                 }
15518                 if (r->out.info) {
15519                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15520                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15521                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15523                 }
15524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15525                         NDR_PULL_ALLOC(ndr, r->out.needed);
15526                 }
15527                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15528                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15532                         NDR_PULL_ALLOC(ndr, r->out.count);
15533                 }
15534                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15535                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15538                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15539         }
15540         return NDR_ERR_SUCCESS;
15541 }
15542
15543 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
15544 {
15545         uint32_t cntr_info_0;
15546         if (flags & NDR_IN) {
15547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15549         }
15550         if (flags & NDR_OUT) {
15551                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15552                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15553                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15554                 }
15555                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15556                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15557                 }
15558         }
15559         return NDR_ERR_SUCCESS;
15560 }
15561
15562 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
15563 {
15564         uint32_t cntr_info_0;
15565         TALLOC_CTX *_mem_save_info_0;
15566         if (flags & NDR_IN) {
15567                 ZERO_STRUCT(r->out);
15568
15569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15571         }
15572         if (flags & NDR_OUT) {
15573                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15574                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15576                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15577                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15578                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15579                 }
15580                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15581                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15582                 }
15583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15584         }
15585         return NDR_ERR_SUCCESS;
15586 }
15587
15588 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
15589 {
15590         uint32_t cntr_info_1;
15591         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
15592         ndr->depth++;
15593         if (flags & NDR_SET_VALUES) {
15594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15595         }
15596         if (flags & NDR_IN) {
15597                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
15598                 ndr->depth++;
15599                 ndr_print_ptr(ndr, "handle", r->in.handle);
15600                 ndr->depth++;
15601                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15602                 ndr->depth--;
15603                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
15604                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
15605                 ndr_print_uint32(ndr, "level", r->in.level);
15606                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15607                 ndr->depth++;
15608                 if (r->in.buffer) {
15609                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15610                 }
15611                 ndr->depth--;
15612                 ndr_print_uint32(ndr, "offered", r->in.offered);
15613                 ndr->depth--;
15614         }
15615         if (flags & NDR_OUT) {
15616                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
15617                 ndr->depth++;
15618                 ndr_print_ptr(ndr, "count", r->out.count);
15619                 ndr->depth++;
15620                 ndr_print_uint32(ndr, "count", *r->out.count);
15621                 ndr->depth--;
15622                 ndr_print_ptr(ndr, "info", r->out.info);
15623                 ndr->depth++;
15624                 if (r->out.info) {
15625                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15626                         ndr->depth++;
15627                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15628                                 char *idx_1=NULL;
15629                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15630                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15631                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
15632                                         free(idx_1);
15633                                 }
15634                         }
15635                         ndr->depth--;
15636                 }
15637                 ndr->depth--;
15638                 ndr_print_ptr(ndr, "needed", r->out.needed);
15639                 ndr->depth++;
15640                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15641                 ndr->depth--;
15642                 ndr_print_WERROR(ndr, "result", r->out.result);
15643                 ndr->depth--;
15644         }
15645         ndr->depth--;
15646 }
15647
15648 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
15649 {
15650         if (flags & NDR_IN) {
15651         }
15652         if (flags & NDR_OUT) {
15653                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15654         }
15655         return NDR_ERR_SUCCESS;
15656 }
15657
15658 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
15659 {
15660         if (flags & NDR_IN) {
15661         }
15662         if (flags & NDR_OUT) {
15663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15664         }
15665         return NDR_ERR_SUCCESS;
15666 }
15667
15668 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
15669 {
15670         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
15671         ndr->depth++;
15672         if (flags & NDR_SET_VALUES) {
15673                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15674         }
15675         if (flags & NDR_IN) {
15676                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
15677                 ndr->depth++;
15678                 ndr->depth--;
15679         }
15680         if (flags & NDR_OUT) {
15681                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
15682                 ndr->depth++;
15683                 ndr_print_WERROR(ndr, "result", r->out.result);
15684                 ndr->depth--;
15685         }
15686         ndr->depth--;
15687 }
15688
15689 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
15690 {
15691         if (flags & NDR_IN) {
15692                 if (r->in.handle == NULL) {
15693                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15694                 }
15695                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15696         }
15697         if (flags & NDR_OUT) {
15698                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15699         }
15700         return NDR_ERR_SUCCESS;
15701 }
15702
15703 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
15704 {
15705         TALLOC_CTX *_mem_save_handle_0;
15706         if (flags & NDR_IN) {
15707                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15708                         NDR_PULL_ALLOC(ndr, r->in.handle);
15709                 }
15710                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15711                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15712                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15713                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15714         }
15715         if (flags & NDR_OUT) {
15716                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15717         }
15718         return NDR_ERR_SUCCESS;
15719 }
15720
15721 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
15722 {
15723         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
15724         ndr->depth++;
15725         if (flags & NDR_SET_VALUES) {
15726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15727         }
15728         if (flags & NDR_IN) {
15729                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
15730                 ndr->depth++;
15731                 ndr_print_ptr(ndr, "handle", r->in.handle);
15732                 ndr->depth++;
15733                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15734                 ndr->depth--;
15735                 ndr->depth--;
15736         }
15737         if (flags & NDR_OUT) {
15738                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
15739                 ndr->depth++;
15740                 ndr_print_WERROR(ndr, "result", r->out.result);
15741                 ndr->depth--;
15742         }
15743         ndr->depth--;
15744 }
15745
15746 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
15747 {
15748         if (flags & NDR_IN) {
15749                 if (r->in.handle == NULL) {
15750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15751                 }
15752                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15753                 if (r->in.info_ctr == NULL) {
15754                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15755                 }
15756                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15757                 if (r->in.devmode_ctr == NULL) {
15758                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15759                 }
15760                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15761                 if (r->in.secdesc_ctr == NULL) {
15762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15763                 }
15764                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15765                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
15766         }
15767         if (flags & NDR_OUT) {
15768                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15769         }
15770         return NDR_ERR_SUCCESS;
15771 }
15772
15773 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
15774 {
15775         TALLOC_CTX *_mem_save_handle_0;
15776         TALLOC_CTX *_mem_save_info_ctr_0;
15777         TALLOC_CTX *_mem_save_devmode_ctr_0;
15778         TALLOC_CTX *_mem_save_secdesc_ctr_0;
15779         if (flags & NDR_IN) {
15780                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15781                         NDR_PULL_ALLOC(ndr, r->in.handle);
15782                 }
15783                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15784                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15785                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15786                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
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_SetPrinterInfoCtr(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                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15795                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
15796                 }
15797                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15798                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
15799                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15800                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15801                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15802                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
15803                 }
15804                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15805                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
15806                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15807                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15808                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
15809         }
15810         if (flags & NDR_OUT) {
15811                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15812         }
15813         return NDR_ERR_SUCCESS;
15814 }
15815
15816 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
15817 {
15818         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
15819         ndr->depth++;
15820         if (flags & NDR_SET_VALUES) {
15821                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15822         }
15823         if (flags & NDR_IN) {
15824                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
15825                 ndr->depth++;
15826                 ndr_print_ptr(ndr, "handle", r->in.handle);
15827                 ndr->depth++;
15828                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15829                 ndr->depth--;
15830                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15831                 ndr->depth++;
15832                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15833                 ndr->depth--;
15834                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
15835                 ndr->depth++;
15836                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
15837                 ndr->depth--;
15838                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15839                 ndr->depth++;
15840                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15841                 ndr->depth--;
15842                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
15843                 ndr->depth--;
15844         }
15845         if (flags & NDR_OUT) {
15846                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
15847                 ndr->depth++;
15848                 ndr_print_WERROR(ndr, "result", r->out.result);
15849                 ndr->depth--;
15850         }
15851         ndr->depth--;
15852 }
15853
15854 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
15855 {
15856         if (flags & NDR_IN) {
15857                 if (r->in.handle == NULL) {
15858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15859                 }
15860                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15863                 if (r->in.buffer) {
15864                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15865                 }
15866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15867         }
15868         if (flags & NDR_OUT) {
15869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15870                 if (r->out.info) {
15871                         {
15872                                 struct ndr_push *_ndr_info;
15873                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15874                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15875                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15876                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15877                         }
15878                 }
15879                 if (r->out.needed == NULL) {
15880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15881                 }
15882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15883                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15884         }
15885         return NDR_ERR_SUCCESS;
15886 }
15887
15888 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
15889 {
15890         uint32_t _ptr_buffer;
15891         uint32_t _ptr_info;
15892         TALLOC_CTX *_mem_save_handle_0;
15893         TALLOC_CTX *_mem_save_buffer_0;
15894         TALLOC_CTX *_mem_save_info_0;
15895         TALLOC_CTX *_mem_save_needed_0;
15896         if (flags & NDR_IN) {
15897                 ZERO_STRUCT(r->out);
15898
15899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15900                         NDR_PULL_ALLOC(ndr, r->in.handle);
15901                 }
15902                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15903                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15904                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15908                 if (_ptr_buffer) {
15909                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15910                 } else {
15911                         r->in.buffer = NULL;
15912                 }
15913                 if (r->in.buffer) {
15914                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15915                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15916                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15918                 }
15919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15920                 NDR_PULL_ALLOC(ndr, r->out.needed);
15921                 ZERO_STRUCTP(r->out.needed);
15922         }
15923         if (flags & NDR_OUT) {
15924                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15925                 if (_ptr_info) {
15926                         NDR_PULL_ALLOC(ndr, r->out.info);
15927                 } else {
15928                         r->out.info = NULL;
15929                 }
15930                 if (r->out.info) {
15931                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15932                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15933                         {
15934                                 struct ndr_pull *_ndr_info;
15935                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15936                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15937                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15938                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15939                         }
15940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15941                 }
15942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15943                         NDR_PULL_ALLOC(ndr, r->out.needed);
15944                 }
15945                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15946                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15950         }
15951         return NDR_ERR_SUCCESS;
15952 }
15953
15954 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
15955 {
15956         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
15957         ndr->depth++;
15958         if (flags & NDR_SET_VALUES) {
15959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15960         }
15961         if (flags & NDR_IN) {
15962                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
15963                 ndr->depth++;
15964                 ndr_print_ptr(ndr, "handle", r->in.handle);
15965                 ndr->depth++;
15966                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15967                 ndr->depth--;
15968                 ndr_print_uint32(ndr, "level", r->in.level);
15969                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15970                 ndr->depth++;
15971                 if (r->in.buffer) {
15972                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15973                 }
15974                 ndr->depth--;
15975                 ndr_print_uint32(ndr, "offered", r->in.offered);
15976                 ndr->depth--;
15977         }
15978         if (flags & NDR_OUT) {
15979                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
15980                 ndr->depth++;
15981                 ndr_print_ptr(ndr, "info", r->out.info);
15982                 ndr->depth++;
15983                 if (r->out.info) {
15984                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15985                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
15986                 }
15987                 ndr->depth--;
15988                 ndr_print_ptr(ndr, "needed", r->out.needed);
15989                 ndr->depth++;
15990                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15991                 ndr->depth--;
15992                 ndr_print_WERROR(ndr, "result", r->out.result);
15993                 ndr->depth--;
15994         }
15995         ndr->depth--;
15996 }
15997
15998 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
15999 {
16000         if (flags & NDR_IN) {
16001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16002                 if (r->in.servername) {
16003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16006                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16007                 }
16008                 if (r->in.info_ctr == NULL) {
16009                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16010                 }
16011                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16012         }
16013         if (flags & NDR_OUT) {
16014                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16015         }
16016         return NDR_ERR_SUCCESS;
16017 }
16018
16019 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
16020 {
16021         uint32_t _ptr_servername;
16022         TALLOC_CTX *_mem_save_servername_0;
16023         TALLOC_CTX *_mem_save_info_ctr_0;
16024         if (flags & NDR_IN) {
16025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16026                 if (_ptr_servername) {
16027                         NDR_PULL_ALLOC(ndr, r->in.servername);
16028                 } else {
16029                         r->in.servername = NULL;
16030                 }
16031                 if (r->in.servername) {
16032                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16033                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16035                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16036                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16037                                 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));
16038                         }
16039                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16040                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16042                 }
16043                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16044                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
16045                 }
16046                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16047                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
16048                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16049                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16050         }
16051         if (flags & NDR_OUT) {
16052                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16053         }
16054         return NDR_ERR_SUCCESS;
16055 }
16056
16057 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
16058 {
16059         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
16060         ndr->depth++;
16061         if (flags & NDR_SET_VALUES) {
16062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16063         }
16064         if (flags & NDR_IN) {
16065                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
16066                 ndr->depth++;
16067                 ndr_print_ptr(ndr, "servername", r->in.servername);
16068                 ndr->depth++;
16069                 if (r->in.servername) {
16070                         ndr_print_string(ndr, "servername", r->in.servername);
16071                 }
16072                 ndr->depth--;
16073                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
16074                 ndr->depth++;
16075                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
16076                 ndr->depth--;
16077                 ndr->depth--;
16078         }
16079         if (flags & NDR_OUT) {
16080                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
16081                 ndr->depth++;
16082                 ndr_print_WERROR(ndr, "result", r->out.result);
16083                 ndr->depth--;
16084         }
16085         ndr->depth--;
16086 }
16087
16088 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
16089 {
16090         if (flags & NDR_IN) {
16091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16092                 if (r->in.server) {
16093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16097                 }
16098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16099                 if (r->in.environment) {
16100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16104                 }
16105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16106                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16107                 if (r->in.buffer) {
16108                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16109                 }
16110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16111         }
16112         if (flags & NDR_OUT) {
16113                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16114                 if (r->out.info) {
16115                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16116                 }
16117                 if (r->out.needed == NULL) {
16118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16119                 }
16120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16121                 if (r->out.count == NULL) {
16122                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16123                 }
16124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16125                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16126         }
16127         return NDR_ERR_SUCCESS;
16128 }
16129
16130 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
16131 {
16132         uint32_t _ptr_server;
16133         uint32_t _ptr_environment;
16134         uint32_t _ptr_buffer;
16135         uint32_t _ptr_info;
16136         TALLOC_CTX *_mem_save_server_0;
16137         TALLOC_CTX *_mem_save_environment_0;
16138         TALLOC_CTX *_mem_save_buffer_0;
16139         TALLOC_CTX *_mem_save_info_0;
16140         TALLOC_CTX *_mem_save_needed_0;
16141         TALLOC_CTX *_mem_save_count_0;
16142         if (flags & NDR_IN) {
16143                 ZERO_STRUCT(r->out);
16144
16145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16146                 if (_ptr_server) {
16147                         NDR_PULL_ALLOC(ndr, r->in.server);
16148                 } else {
16149                         r->in.server = NULL;
16150                 }
16151                 if (r->in.server) {
16152                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16153                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16156                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16157                                 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));
16158                         }
16159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16162                 }
16163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16164                 if (_ptr_environment) {
16165                         NDR_PULL_ALLOC(ndr, r->in.environment);
16166                 } else {
16167                         r->in.environment = NULL;
16168                 }
16169                 if (r->in.environment) {
16170                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16171                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16174                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16175                                 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));
16176                         }
16177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16180                 }
16181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16183                 if (_ptr_buffer) {
16184                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16185                 } else {
16186                         r->in.buffer = NULL;
16187                 }
16188                 if (r->in.buffer) {
16189                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16190                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16191                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16193                 }
16194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16195                 NDR_PULL_ALLOC(ndr, r->out.needed);
16196                 ZERO_STRUCTP(r->out.needed);
16197                 NDR_PULL_ALLOC(ndr, r->out.count);
16198                 ZERO_STRUCTP(r->out.count);
16199         }
16200         if (flags & NDR_OUT) {
16201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16202                 if (_ptr_info) {
16203                         NDR_PULL_ALLOC(ndr, r->out.info);
16204                 } else {
16205                         r->out.info = NULL;
16206                 }
16207                 if (r->out.info) {
16208                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16209                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16210                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16212                 }
16213                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16214                         NDR_PULL_ALLOC(ndr, r->out.needed);
16215                 }
16216                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16217                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16219                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16221                         NDR_PULL_ALLOC(ndr, r->out.count);
16222                 }
16223                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16224                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16227                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16228         }
16229         return NDR_ERR_SUCCESS;
16230 }
16231
16232 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
16233 {
16234         uint32_t cntr_info_0;
16235         if (flags & NDR_IN) {
16236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16238         }
16239         if (flags & NDR_OUT) {
16240                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16241                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16242                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16243                 }
16244                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16245                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16246                 }
16247         }
16248         return NDR_ERR_SUCCESS;
16249 }
16250
16251 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
16252 {
16253         uint32_t cntr_info_0;
16254         TALLOC_CTX *_mem_save_info_0;
16255         if (flags & NDR_IN) {
16256                 ZERO_STRUCT(r->out);
16257
16258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16260         }
16261         if (flags & NDR_OUT) {
16262                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16263                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16264                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16265                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16266                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16267                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16268                 }
16269                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16270                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16271                 }
16272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16273         }
16274         return NDR_ERR_SUCCESS;
16275 }
16276
16277 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
16278 {
16279         uint32_t cntr_info_1;
16280         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
16281         ndr->depth++;
16282         if (flags & NDR_SET_VALUES) {
16283                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16284         }
16285         if (flags & NDR_IN) {
16286                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
16287                 ndr->depth++;
16288                 ndr_print_ptr(ndr, "server", r->in.server);
16289                 ndr->depth++;
16290                 if (r->in.server) {
16291                         ndr_print_string(ndr, "server", r->in.server);
16292                 }
16293                 ndr->depth--;
16294                 ndr_print_ptr(ndr, "environment", r->in.environment);
16295                 ndr->depth++;
16296                 if (r->in.environment) {
16297                         ndr_print_string(ndr, "environment", r->in.environment);
16298                 }
16299                 ndr->depth--;
16300                 ndr_print_uint32(ndr, "level", r->in.level);
16301                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16302                 ndr->depth++;
16303                 if (r->in.buffer) {
16304                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16305                 }
16306                 ndr->depth--;
16307                 ndr_print_uint32(ndr, "offered", r->in.offered);
16308                 ndr->depth--;
16309         }
16310         if (flags & NDR_OUT) {
16311                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
16312                 ndr->depth++;
16313                 ndr_print_ptr(ndr, "count", r->out.count);
16314                 ndr->depth++;
16315                 ndr_print_uint32(ndr, "count", *r->out.count);
16316                 ndr->depth--;
16317                 ndr_print_ptr(ndr, "info", r->out.info);
16318                 ndr->depth++;
16319                 if (r->out.info) {
16320                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16321                         ndr->depth++;
16322                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16323                                 char *idx_1=NULL;
16324                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16325                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16326                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
16327                                         free(idx_1);
16328                                 }
16329                         }
16330                         ndr->depth--;
16331                 }
16332                 ndr->depth--;
16333                 ndr_print_ptr(ndr, "needed", r->out.needed);
16334                 ndr->depth++;
16335                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16336                 ndr->depth--;
16337                 ndr_print_WERROR(ndr, "result", r->out.result);
16338                 ndr->depth--;
16339         }
16340         ndr->depth--;
16341 }
16342
16343 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
16344 {
16345         if (flags & NDR_IN) {
16346         }
16347         if (flags & NDR_OUT) {
16348                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16349         }
16350         return NDR_ERR_SUCCESS;
16351 }
16352
16353 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
16354 {
16355         if (flags & NDR_IN) {
16356         }
16357         if (flags & NDR_OUT) {
16358                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16359         }
16360         return NDR_ERR_SUCCESS;
16361 }
16362
16363 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
16364 {
16365         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
16366         ndr->depth++;
16367         if (flags & NDR_SET_VALUES) {
16368                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16369         }
16370         if (flags & NDR_IN) {
16371                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
16372                 ndr->depth++;
16373                 ndr->depth--;
16374         }
16375         if (flags & NDR_OUT) {
16376                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
16377                 ndr->depth++;
16378                 ndr_print_WERROR(ndr, "result", r->out.result);
16379                 ndr->depth--;
16380         }
16381         ndr->depth--;
16382 }
16383
16384 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16385 {
16386         if (flags & NDR_IN) {
16387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16388                 if (r->in.server) {
16389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16392                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16393                 }
16394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16395                 if (r->in.environment) {
16396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16399                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16400                 }
16401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16403                 if (r->in.buffer) {
16404                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16405                 }
16406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16407         }
16408         if (flags & NDR_OUT) {
16409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16410                 if (r->out.info) {
16411                         {
16412                                 struct ndr_push *_ndr_info;
16413                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16414                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16415                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16416                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16417                         }
16418                 }
16419                 if (r->out.needed == NULL) {
16420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16421                 }
16422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16423                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16424         }
16425         return NDR_ERR_SUCCESS;
16426 }
16427
16428 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
16429 {
16430         uint32_t _ptr_server;
16431         uint32_t _ptr_environment;
16432         uint32_t _ptr_buffer;
16433         uint32_t _ptr_info;
16434         TALLOC_CTX *_mem_save_server_0;
16435         TALLOC_CTX *_mem_save_environment_0;
16436         TALLOC_CTX *_mem_save_buffer_0;
16437         TALLOC_CTX *_mem_save_info_0;
16438         TALLOC_CTX *_mem_save_needed_0;
16439         if (flags & NDR_IN) {
16440                 ZERO_STRUCT(r->out);
16441
16442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16443                 if (_ptr_server) {
16444                         NDR_PULL_ALLOC(ndr, r->in.server);
16445                 } else {
16446                         r->in.server = NULL;
16447                 }
16448                 if (r->in.server) {
16449                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16450                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16451                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16452                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16453                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16454                                 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));
16455                         }
16456                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16457                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16458                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16459                 }
16460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16461                 if (_ptr_environment) {
16462                         NDR_PULL_ALLOC(ndr, r->in.environment);
16463                 } else {
16464                         r->in.environment = NULL;
16465                 }
16466                 if (r->in.environment) {
16467                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16468                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16469                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16470                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16471                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16472                                 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));
16473                         }
16474                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16475                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16477                 }
16478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16480                 if (_ptr_buffer) {
16481                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16482                 } else {
16483                         r->in.buffer = NULL;
16484                 }
16485                 if (r->in.buffer) {
16486                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16487                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16488                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16490                 }
16491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16492                 NDR_PULL_ALLOC(ndr, r->out.needed);
16493                 ZERO_STRUCTP(r->out.needed);
16494         }
16495         if (flags & NDR_OUT) {
16496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16497                 if (_ptr_info) {
16498                         NDR_PULL_ALLOC(ndr, r->out.info);
16499                 } else {
16500                         r->out.info = NULL;
16501                 }
16502                 if (r->out.info) {
16503                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16504                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16505                         {
16506                                 struct ndr_pull *_ndr_info;
16507                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16508                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16509                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16510                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16511                         }
16512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16513                 }
16514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16515                         NDR_PULL_ALLOC(ndr, r->out.needed);
16516                 }
16517                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16518                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16521                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16522         }
16523         return NDR_ERR_SUCCESS;
16524 }
16525
16526 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16527 {
16528         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
16529         ndr->depth++;
16530         if (flags & NDR_SET_VALUES) {
16531                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16532         }
16533         if (flags & NDR_IN) {
16534                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
16535                 ndr->depth++;
16536                 ndr_print_ptr(ndr, "server", r->in.server);
16537                 ndr->depth++;
16538                 if (r->in.server) {
16539                         ndr_print_string(ndr, "server", r->in.server);
16540                 }
16541                 ndr->depth--;
16542                 ndr_print_ptr(ndr, "environment", r->in.environment);
16543                 ndr->depth++;
16544                 if (r->in.environment) {
16545                         ndr_print_string(ndr, "environment", r->in.environment);
16546                 }
16547                 ndr->depth--;
16548                 ndr_print_uint32(ndr, "level", r->in.level);
16549                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16550                 ndr->depth++;
16551                 if (r->in.buffer) {
16552                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16553                 }
16554                 ndr->depth--;
16555                 ndr_print_uint32(ndr, "offered", r->in.offered);
16556                 ndr->depth--;
16557         }
16558         if (flags & NDR_OUT) {
16559                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
16560                 ndr->depth++;
16561                 ndr_print_ptr(ndr, "info", r->out.info);
16562                 ndr->depth++;
16563                 if (r->out.info) {
16564                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16565                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
16566                 }
16567                 ndr->depth--;
16568                 ndr_print_ptr(ndr, "needed", r->out.needed);
16569                 ndr->depth++;
16570                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16571                 ndr->depth--;
16572                 ndr_print_WERROR(ndr, "result", r->out.result);
16573                 ndr->depth--;
16574         }
16575         ndr->depth--;
16576 }
16577
16578 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
16579 {
16580         if (flags & NDR_IN) {
16581                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16582                 if (r->in.server) {
16583                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16584                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16585                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16586                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16587                 }
16588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16591                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16595                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16596         }
16597         if (flags & NDR_OUT) {
16598                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16599         }
16600         return NDR_ERR_SUCCESS;
16601 }
16602
16603 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
16604 {
16605         uint32_t _ptr_server;
16606         TALLOC_CTX *_mem_save_server_0;
16607         if (flags & NDR_IN) {
16608                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16609                 if (_ptr_server) {
16610                         NDR_PULL_ALLOC(ndr, r->in.server);
16611                 } else {
16612                         r->in.server = NULL;
16613                 }
16614                 if (r->in.server) {
16615                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16616                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16617                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16618                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16619                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16620                                 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));
16621                         }
16622                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16623                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16625                 }
16626                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16627                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16628                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16629                         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));
16630                 }
16631                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16632                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16633                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16634                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16635                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16636                         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));
16637                 }
16638                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16639                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16640         }
16641         if (flags & NDR_OUT) {
16642                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16643         }
16644         return NDR_ERR_SUCCESS;
16645 }
16646
16647 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
16648 {
16649         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
16650         ndr->depth++;
16651         if (flags & NDR_SET_VALUES) {
16652                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16653         }
16654         if (flags & NDR_IN) {
16655                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
16656                 ndr->depth++;
16657                 ndr_print_ptr(ndr, "server", r->in.server);
16658                 ndr->depth++;
16659                 if (r->in.server) {
16660                         ndr_print_string(ndr, "server", r->in.server);
16661                 }
16662                 ndr->depth--;
16663                 ndr_print_string(ndr, "architecture", r->in.architecture);
16664                 ndr_print_string(ndr, "driver", r->in.driver);
16665                 ndr->depth--;
16666         }
16667         if (flags & NDR_OUT) {
16668                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
16669                 ndr->depth++;
16670                 ndr_print_WERROR(ndr, "result", r->out.result);
16671                 ndr->depth--;
16672         }
16673         ndr->depth--;
16674 }
16675
16676 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
16677 {
16678         if (flags & NDR_IN) {
16679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16680                 if (r->in.server) {
16681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16684                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16685                 }
16686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16689                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16693                 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));
16694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16697                 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));
16698         }
16699         if (flags & NDR_OUT) {
16700                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16701         }
16702         return NDR_ERR_SUCCESS;
16703 }
16704
16705 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
16706 {
16707         uint32_t _ptr_server;
16708         TALLOC_CTX *_mem_save_server_0;
16709         if (flags & NDR_IN) {
16710                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16711                 if (_ptr_server) {
16712                         NDR_PULL_ALLOC(ndr, r->in.server);
16713                 } else {
16714                         r->in.server = NULL;
16715                 }
16716                 if (r->in.server) {
16717                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16718                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16719                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16720                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16721                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16722                                 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));
16723                         }
16724                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16725                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16727                 }
16728                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16729                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16730                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16731                         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));
16732                 }
16733                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16734                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16735                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
16736                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
16737                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
16738                         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));
16739                 }
16740                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
16741                 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));
16742                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
16743                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
16744                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
16745                         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));
16746                 }
16747                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
16748                 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));
16749         }
16750         if (flags & NDR_OUT) {
16751                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16752         }
16753         return NDR_ERR_SUCCESS;
16754 }
16755
16756 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
16757 {
16758         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
16759         ndr->depth++;
16760         if (flags & NDR_SET_VALUES) {
16761                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16762         }
16763         if (flags & NDR_IN) {
16764                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
16765                 ndr->depth++;
16766                 ndr_print_ptr(ndr, "server", r->in.server);
16767                 ndr->depth++;
16768                 if (r->in.server) {
16769                         ndr_print_string(ndr, "server", r->in.server);
16770                 }
16771                 ndr->depth--;
16772                 ndr_print_string(ndr, "architecture", r->in.architecture);
16773                 ndr_print_string(ndr, "path_name", r->in.path_name);
16774                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
16775                 ndr->depth--;
16776         }
16777         if (flags & NDR_OUT) {
16778                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
16779                 ndr->depth++;
16780                 ndr_print_WERROR(ndr, "result", r->out.result);
16781                 ndr->depth--;
16782         }
16783         ndr->depth--;
16784 }
16785
16786 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
16787 {
16788         if (flags & NDR_IN) {
16789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16790                 if (r->in.servername) {
16791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16794                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16795                 }
16796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16797                 if (r->in.environment) {
16798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16801                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16802                 }
16803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16805                 if (r->in.buffer) {
16806                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16807                 }
16808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16809         }
16810         if (flags & NDR_OUT) {
16811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16812                 if (r->out.info) {
16813                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16814                 }
16815                 if (r->out.needed == NULL) {
16816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16817                 }
16818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16819                 if (r->out.count == NULL) {
16820                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16821                 }
16822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16823                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16824         }
16825         return NDR_ERR_SUCCESS;
16826 }
16827
16828 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
16829 {
16830         uint32_t _ptr_servername;
16831         uint32_t _ptr_environment;
16832         uint32_t _ptr_buffer;
16833         uint32_t _ptr_info;
16834         TALLOC_CTX *_mem_save_servername_0;
16835         TALLOC_CTX *_mem_save_environment_0;
16836         TALLOC_CTX *_mem_save_buffer_0;
16837         TALLOC_CTX *_mem_save_info_0;
16838         TALLOC_CTX *_mem_save_needed_0;
16839         TALLOC_CTX *_mem_save_count_0;
16840         if (flags & NDR_IN) {
16841                 ZERO_STRUCT(r->out);
16842
16843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16844                 if (_ptr_servername) {
16845                         NDR_PULL_ALLOC(ndr, r->in.servername);
16846                 } else {
16847                         r->in.servername = NULL;
16848                 }
16849                 if (r->in.servername) {
16850                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16851                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16854                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
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.servername), ndr_get_array_length(ndr, &r->in.servername));
16856                         }
16857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_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                 NDR_PULL_ALLOC(ndr, r->out.count);
16896                 ZERO_STRUCTP(r->out.count);
16897         }
16898         if (flags & NDR_OUT) {
16899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16900                 if (_ptr_info) {
16901                         NDR_PULL_ALLOC(ndr, r->out.info);
16902                 } else {
16903                         r->out.info = NULL;
16904                 }
16905                 if (r->out.info) {
16906                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16907                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16908                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16910                 }
16911                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16912                         NDR_PULL_ALLOC(ndr, r->out.needed);
16913                 }
16914                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16915                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16917                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16919                         NDR_PULL_ALLOC(ndr, r->out.count);
16920                 }
16921                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16922                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16925                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16926         }
16927         return NDR_ERR_SUCCESS;
16928 }
16929
16930 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
16931 {
16932         uint32_t cntr_info_0;
16933         if (flags & NDR_IN) {
16934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16936         }
16937         if (flags & NDR_OUT) {
16938                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16939                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16940                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16941                 }
16942                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16943                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16944                 }
16945         }
16946         return NDR_ERR_SUCCESS;
16947 }
16948
16949 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
16950 {
16951         uint32_t cntr_info_0;
16952         TALLOC_CTX *_mem_save_info_0;
16953         if (flags & NDR_IN) {
16954                 ZERO_STRUCT(r->out);
16955
16956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16958         }
16959         if (flags & NDR_OUT) {
16960                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16961                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16962                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16963                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16964                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16965                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16966                 }
16967                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16968                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16969                 }
16970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16971         }
16972         return NDR_ERR_SUCCESS;
16973 }
16974
16975 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
16976 {
16977         uint32_t cntr_info_1;
16978         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
16979         ndr->depth++;
16980         if (flags & NDR_SET_VALUES) {
16981                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16982         }
16983         if (flags & NDR_IN) {
16984                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
16985                 ndr->depth++;
16986                 ndr_print_ptr(ndr, "servername", r->in.servername);
16987                 ndr->depth++;
16988                 if (r->in.servername) {
16989                         ndr_print_string(ndr, "servername", r->in.servername);
16990                 }
16991                 ndr->depth--;
16992                 ndr_print_ptr(ndr, "environment", r->in.environment);
16993                 ndr->depth++;
16994                 if (r->in.environment) {
16995                         ndr_print_string(ndr, "environment", r->in.environment);
16996                 }
16997                 ndr->depth--;
16998                 ndr_print_uint32(ndr, "level", r->in.level);
16999                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17000                 ndr->depth++;
17001                 if (r->in.buffer) {
17002                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17003                 }
17004                 ndr->depth--;
17005                 ndr_print_uint32(ndr, "offered", r->in.offered);
17006                 ndr->depth--;
17007         }
17008         if (flags & NDR_OUT) {
17009                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
17010                 ndr->depth++;
17011                 ndr_print_ptr(ndr, "count", r->out.count);
17012                 ndr->depth++;
17013                 ndr_print_uint32(ndr, "count", *r->out.count);
17014                 ndr->depth--;
17015                 ndr_print_ptr(ndr, "info", r->out.info);
17016                 ndr->depth++;
17017                 if (r->out.info) {
17018                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
17019                         ndr->depth++;
17020                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
17021                                 char *idx_1=NULL;
17022                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
17023                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
17024                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
17025                                         free(idx_1);
17026                                 }
17027                         }
17028                         ndr->depth--;
17029                 }
17030                 ndr->depth--;
17031                 ndr_print_ptr(ndr, "needed", r->out.needed);
17032                 ndr->depth++;
17033                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17034                 ndr->depth--;
17035                 ndr_print_WERROR(ndr, "result", r->out.result);
17036                 ndr->depth--;
17037         }
17038         ndr->depth--;
17039 }
17040
17041 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
17042 {
17043         if (flags & NDR_IN) {
17044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
17045                 if (r->in.server) {
17046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
17047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
17049                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17050                 }
17051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
17052                 if (r->in.environment) {
17053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17057                 }
17058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17060                 if (r->in.buffer) {
17061                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17062                 }
17063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17064         }
17065         if (flags & NDR_OUT) {
17066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17067                 if (r->out.info) {
17068                         {
17069                                 struct ndr_push *_ndr_info;
17070                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17071                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
17072                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17073                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17074                         }
17075                 }
17076                 if (r->out.needed == NULL) {
17077                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17078                 }
17079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17081         }
17082         return NDR_ERR_SUCCESS;
17083 }
17084
17085 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
17086 {
17087         uint32_t _ptr_server;
17088         uint32_t _ptr_environment;
17089         uint32_t _ptr_buffer;
17090         uint32_t _ptr_info;
17091         TALLOC_CTX *_mem_save_server_0;
17092         TALLOC_CTX *_mem_save_environment_0;
17093         TALLOC_CTX *_mem_save_buffer_0;
17094         TALLOC_CTX *_mem_save_info_0;
17095         TALLOC_CTX *_mem_save_needed_0;
17096         if (flags & NDR_IN) {
17097                 ZERO_STRUCT(r->out);
17098
17099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
17100                 if (_ptr_server) {
17101                         NDR_PULL_ALLOC(ndr, r->in.server);
17102                 } else {
17103                         r->in.server = NULL;
17104                 }
17105                 if (r->in.server) {
17106                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
17107                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
17108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
17109                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
17110                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
17111                                 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));
17112                         }
17113                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
17114                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
17115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
17116                 }
17117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17118                 if (_ptr_environment) {
17119                         NDR_PULL_ALLOC(ndr, r->in.environment);
17120                 } else {
17121                         r->in.environment = NULL;
17122                 }
17123                 if (r->in.environment) {
17124                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17125                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
17126                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
17127                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
17128                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
17129                                 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));
17130                         }
17131                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
17132                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
17133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17134                 }
17135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17137                 if (_ptr_buffer) {
17138                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17139                 } else {
17140                         r->in.buffer = NULL;
17141                 }
17142                 if (r->in.buffer) {
17143                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17144                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17145                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17147                 }
17148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17149                 NDR_PULL_ALLOC(ndr, r->out.needed);
17150                 ZERO_STRUCTP(r->out.needed);
17151         }
17152         if (flags & NDR_OUT) {
17153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17154                 if (_ptr_info) {
17155                         NDR_PULL_ALLOC(ndr, r->out.info);
17156                 } else {
17157                         r->out.info = NULL;
17158                 }
17159                 if (r->out.info) {
17160                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17161                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17162                         {
17163                                 struct ndr_pull *_ndr_info;
17164                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17165                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
17166                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17167                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17168                         }
17169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17170                 }
17171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17172                         NDR_PULL_ALLOC(ndr, r->out.needed);
17173                 }
17174                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17175                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17178                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17179         }
17180         return NDR_ERR_SUCCESS;
17181 }
17182
17183 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
17184 {
17185         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
17186         ndr->depth++;
17187         if (flags & NDR_SET_VALUES) {
17188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17189         }
17190         if (flags & NDR_IN) {
17191                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
17192                 ndr->depth++;
17193                 ndr_print_ptr(ndr, "server", r->in.server);
17194                 ndr->depth++;
17195                 if (r->in.server) {
17196                         ndr_print_string(ndr, "server", r->in.server);
17197                 }
17198                 ndr->depth--;
17199                 ndr_print_ptr(ndr, "environment", r->in.environment);
17200                 ndr->depth++;
17201                 if (r->in.environment) {
17202                         ndr_print_string(ndr, "environment", r->in.environment);
17203                 }
17204                 ndr->depth--;
17205                 ndr_print_uint32(ndr, "level", r->in.level);
17206                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17207                 ndr->depth++;
17208                 if (r->in.buffer) {
17209                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17210                 }
17211                 ndr->depth--;
17212                 ndr_print_uint32(ndr, "offered", r->in.offered);
17213                 ndr->depth--;
17214         }
17215         if (flags & NDR_OUT) {
17216                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
17217                 ndr->depth++;
17218                 ndr_print_ptr(ndr, "info", r->out.info);
17219                 ndr->depth++;
17220                 if (r->out.info) {
17221                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
17222                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
17223                 }
17224                 ndr->depth--;
17225                 ndr_print_ptr(ndr, "needed", r->out.needed);
17226                 ndr->depth++;
17227                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17228                 ndr->depth--;
17229                 ndr_print_WERROR(ndr, "result", r->out.result);
17230                 ndr->depth--;
17231         }
17232         ndr->depth--;
17233 }
17234
17235 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
17236 {
17237         if (flags & NDR_IN) {
17238                 if (r->in.handle == NULL) {
17239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17240                 }
17241                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17243                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
17244                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17245         }
17246         if (flags & NDR_OUT) {
17247                 if (r->out.job_id == NULL) {
17248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17249                 }
17250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
17251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17252         }
17253         return NDR_ERR_SUCCESS;
17254 }
17255
17256 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
17257 {
17258         TALLOC_CTX *_mem_save_handle_0;
17259         TALLOC_CTX *_mem_save_job_id_0;
17260         if (flags & NDR_IN) {
17261                 ZERO_STRUCT(r->out);
17262
17263                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17264                         NDR_PULL_ALLOC(ndr, r->in.handle);
17265                 }
17266                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17267                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17268                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17269                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17271                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17272                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17273                 NDR_PULL_ALLOC(ndr, r->out.job_id);
17274                 ZERO_STRUCTP(r->out.job_id);
17275         }
17276         if (flags & NDR_OUT) {
17277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17278                         NDR_PULL_ALLOC(ndr, r->out.job_id);
17279                 }
17280                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
17281                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
17282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
17283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
17284                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17285         }
17286         return NDR_ERR_SUCCESS;
17287 }
17288
17289 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
17290 {
17291         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
17292         ndr->depth++;
17293         if (flags & NDR_SET_VALUES) {
17294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17295         }
17296         if (flags & NDR_IN) {
17297                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
17298                 ndr->depth++;
17299                 ndr_print_ptr(ndr, "handle", r->in.handle);
17300                 ndr->depth++;
17301                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17302                 ndr->depth--;
17303                 ndr_print_uint32(ndr, "level", r->in.level);
17304                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
17305                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
17306                 ndr->depth--;
17307         }
17308         if (flags & NDR_OUT) {
17309                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
17310                 ndr->depth++;
17311                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
17312                 ndr->depth++;
17313                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
17314                 ndr->depth--;
17315                 ndr_print_WERROR(ndr, "result", r->out.result);
17316                 ndr->depth--;
17317         }
17318         ndr->depth--;
17319 }
17320
17321 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
17322 {
17323         if (flags & NDR_IN) {
17324                 if (r->in.handle == NULL) {
17325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17326                 }
17327                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17328         }
17329         if (flags & NDR_OUT) {
17330                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17331         }
17332         return NDR_ERR_SUCCESS;
17333 }
17334
17335 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
17336 {
17337         TALLOC_CTX *_mem_save_handle_0;
17338         if (flags & NDR_IN) {
17339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17340                         NDR_PULL_ALLOC(ndr, r->in.handle);
17341                 }
17342                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17343                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17344                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17346         }
17347         if (flags & NDR_OUT) {
17348                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17349         }
17350         return NDR_ERR_SUCCESS;
17351 }
17352
17353 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
17354 {
17355         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
17356         ndr->depth++;
17357         if (flags & NDR_SET_VALUES) {
17358                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17359         }
17360         if (flags & NDR_IN) {
17361                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
17362                 ndr->depth++;
17363                 ndr_print_ptr(ndr, "handle", r->in.handle);
17364                 ndr->depth++;
17365                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17366                 ndr->depth--;
17367                 ndr->depth--;
17368         }
17369         if (flags & NDR_OUT) {
17370                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
17371                 ndr->depth++;
17372                 ndr_print_WERROR(ndr, "result", r->out.result);
17373                 ndr->depth--;
17374         }
17375         ndr->depth--;
17376 }
17377
17378 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
17379 {
17380         if (flags & NDR_IN) {
17381                 if (r->in.handle == NULL) {
17382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17383                 }
17384                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17385                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
17387         }
17388         if (flags & NDR_OUT) {
17389                 if (r->out.num_written == NULL) {
17390                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17391                 }
17392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
17393                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17394         }
17395         return NDR_ERR_SUCCESS;
17396 }
17397
17398 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
17399 {
17400         TALLOC_CTX *_mem_save_handle_0;
17401         TALLOC_CTX *_mem_save_num_written_0;
17402         if (flags & NDR_IN) {
17403                 ZERO_STRUCT(r->out);
17404
17405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17406                         NDR_PULL_ALLOC(ndr, r->in.handle);
17407                 }
17408                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17410                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17412                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
17413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
17414                 NDR_PULL_ALLOC(ndr, r->out.num_written);
17415                 ZERO_STRUCTP(r->out.num_written);
17416         }
17417         if (flags & NDR_OUT) {
17418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17419                         NDR_PULL_ALLOC(ndr, r->out.num_written);
17420                 }
17421                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
17422                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
17423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
17424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
17425                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17426         }
17427         return NDR_ERR_SUCCESS;
17428 }
17429
17430 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
17431 {
17432         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
17433         ndr->depth++;
17434         if (flags & NDR_SET_VALUES) {
17435                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17436         }
17437         if (flags & NDR_IN) {
17438                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
17439                 ndr->depth++;
17440                 ndr_print_ptr(ndr, "handle", r->in.handle);
17441                 ndr->depth++;
17442                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17443                 ndr->depth--;
17444                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
17445                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
17446                 ndr->depth--;
17447         }
17448         if (flags & NDR_OUT) {
17449                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
17450                 ndr->depth++;
17451                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
17452                 ndr->depth++;
17453                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
17454                 ndr->depth--;
17455                 ndr_print_WERROR(ndr, "result", r->out.result);
17456                 ndr->depth--;
17457         }
17458         ndr->depth--;
17459 }
17460
17461 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
17462 {
17463         if (flags & NDR_IN) {
17464                 if (r->in.handle == NULL) {
17465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17466                 }
17467                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17468         }
17469         if (flags & NDR_OUT) {
17470                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17471         }
17472         return NDR_ERR_SUCCESS;
17473 }
17474
17475 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
17476 {
17477         TALLOC_CTX *_mem_save_handle_0;
17478         if (flags & NDR_IN) {
17479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17480                         NDR_PULL_ALLOC(ndr, r->in.handle);
17481                 }
17482                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17483                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17484                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17486         }
17487         if (flags & NDR_OUT) {
17488                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17489         }
17490         return NDR_ERR_SUCCESS;
17491 }
17492
17493 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
17494 {
17495         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
17496         ndr->depth++;
17497         if (flags & NDR_SET_VALUES) {
17498                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17499         }
17500         if (flags & NDR_IN) {
17501                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
17502                 ndr->depth++;
17503                 ndr_print_ptr(ndr, "handle", r->in.handle);
17504                 ndr->depth++;
17505                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17506                 ndr->depth--;
17507                 ndr->depth--;
17508         }
17509         if (flags & NDR_OUT) {
17510                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
17511                 ndr->depth++;
17512                 ndr_print_WERROR(ndr, "result", r->out.result);
17513                 ndr->depth--;
17514         }
17515         ndr->depth--;
17516 }
17517
17518 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
17519 {
17520         if (flags & NDR_IN) {
17521                 if (r->in.handle == NULL) {
17522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17523                 }
17524                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17525         }
17526         if (flags & NDR_OUT) {
17527                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17528         }
17529         return NDR_ERR_SUCCESS;
17530 }
17531
17532 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
17533 {
17534         TALLOC_CTX *_mem_save_handle_0;
17535         if (flags & NDR_IN) {
17536                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17537                         NDR_PULL_ALLOC(ndr, r->in.handle);
17538                 }
17539                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17540                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17541                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17542                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17543         }
17544         if (flags & NDR_OUT) {
17545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17546         }
17547         return NDR_ERR_SUCCESS;
17548 }
17549
17550 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
17551 {
17552         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
17553         ndr->depth++;
17554         if (flags & NDR_SET_VALUES) {
17555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17556         }
17557         if (flags & NDR_IN) {
17558                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
17559                 ndr->depth++;
17560                 ndr_print_ptr(ndr, "handle", r->in.handle);
17561                 ndr->depth++;
17562                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17563                 ndr->depth--;
17564                 ndr->depth--;
17565         }
17566         if (flags & NDR_OUT) {
17567                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
17568                 ndr->depth++;
17569                 ndr_print_WERROR(ndr, "result", r->out.result);
17570                 ndr->depth--;
17571         }
17572         ndr->depth--;
17573 }
17574
17575 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
17576 {
17577         if (flags & NDR_IN) {
17578                 if (r->in.handle == NULL) {
17579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17580                 }
17581                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17583         }
17584         if (flags & NDR_OUT) {
17585                 if (r->out.data == NULL) {
17586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17587                 }
17588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17589                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
17590                 if (r->out._data_size == NULL) {
17591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17592                 }
17593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
17594                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17595         }
17596         return NDR_ERR_SUCCESS;
17597 }
17598
17599 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
17600 {
17601         TALLOC_CTX *_mem_save_handle_0;
17602         TALLOC_CTX *_mem_save__data_size_0;
17603         if (flags & NDR_IN) {
17604                 ZERO_STRUCT(r->out);
17605
17606                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17607                         NDR_PULL_ALLOC(ndr, r->in.handle);
17608                 }
17609                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17610                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17611                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
17614                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
17615                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
17616                 NDR_PULL_ALLOC(ndr, r->out._data_size);
17617                 ZERO_STRUCTP(r->out._data_size);
17618         }
17619         if (flags & NDR_OUT) {
17620                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
17621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17622                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
17623                 }
17624                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
17625                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17626                         NDR_PULL_ALLOC(ndr, r->out._data_size);
17627                 }
17628                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
17629                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
17630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
17631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
17632                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17633                 if (r->out.data) {
17634                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
17635                 }
17636         }
17637         return NDR_ERR_SUCCESS;
17638 }
17639
17640 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
17641 {
17642         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
17643         ndr->depth++;
17644         if (flags & NDR_SET_VALUES) {
17645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17646         }
17647         if (flags & NDR_IN) {
17648                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
17649                 ndr->depth++;
17650                 ndr_print_ptr(ndr, "handle", r->in.handle);
17651                 ndr->depth++;
17652                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17653                 ndr->depth--;
17654                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
17655                 ndr->depth--;
17656         }
17657         if (flags & NDR_OUT) {
17658                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
17659                 ndr->depth++;
17660                 ndr_print_ptr(ndr, "data", r->out.data);
17661                 ndr->depth++;
17662                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
17663                 ndr->depth--;
17664                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
17665                 ndr->depth++;
17666                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
17667                 ndr->depth--;
17668                 ndr_print_WERROR(ndr, "result", r->out.result);
17669                 ndr->depth--;
17670         }
17671         ndr->depth--;
17672 }
17673
17674 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
17675 {
17676         if (flags & NDR_IN) {
17677                 if (r->in.handle == NULL) {
17678                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17679                 }
17680                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17681         }
17682         if (flags & NDR_OUT) {
17683                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17684         }
17685         return NDR_ERR_SUCCESS;
17686 }
17687
17688 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
17689 {
17690         TALLOC_CTX *_mem_save_handle_0;
17691         if (flags & NDR_IN) {
17692                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17693                         NDR_PULL_ALLOC(ndr, r->in.handle);
17694                 }
17695                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17696                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17697                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17698                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17699         }
17700         if (flags & NDR_OUT) {
17701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17702         }
17703         return NDR_ERR_SUCCESS;
17704 }
17705
17706 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
17707 {
17708         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
17709         ndr->depth++;
17710         if (flags & NDR_SET_VALUES) {
17711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17712         }
17713         if (flags & NDR_IN) {
17714                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
17715                 ndr->depth++;
17716                 ndr_print_ptr(ndr, "handle", r->in.handle);
17717                 ndr->depth++;
17718                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17719                 ndr->depth--;
17720                 ndr->depth--;
17721         }
17722         if (flags & NDR_OUT) {
17723                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
17724                 ndr->depth++;
17725                 ndr_print_WERROR(ndr, "result", r->out.result);
17726                 ndr->depth--;
17727         }
17728         ndr->depth--;
17729 }
17730
17731 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
17732 {
17733         if (flags & NDR_IN) {
17734                 if (r->in.handle == NULL) {
17735                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17736                 }
17737                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17740                 if (r->in.buffer) {
17741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17742                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
17743                 }
17744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17745         }
17746         if (flags & NDR_OUT) {
17747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
17748                 if (r->out.buffer) {
17749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17750                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
17751                 }
17752                 if (r->out.needed == NULL) {
17753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17754                 }
17755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17756                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17757         }
17758         return NDR_ERR_SUCCESS;
17759 }
17760
17761 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
17762 {
17763         uint32_t _ptr_buffer;
17764         TALLOC_CTX *_mem_save_handle_0;
17765         TALLOC_CTX *_mem_save_buffer_0;
17766         TALLOC_CTX *_mem_save_needed_0;
17767         if (flags & NDR_IN) {
17768                 ZERO_STRUCT(r->out);
17769
17770                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17771                         NDR_PULL_ALLOC(ndr, r->in.handle);
17772                 }
17773                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17774                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17775                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17776                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17779                 if (_ptr_buffer) {
17780                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17781                 } else {
17782                         r->in.buffer = NULL;
17783                 }
17784                 if (r->in.buffer) {
17785                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17786                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17787                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
17788                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
17789                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
17790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17791                 }
17792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17793                 NDR_PULL_ALLOC(ndr, r->out.needed);
17794                 ZERO_STRUCTP(r->out.needed);
17795                 if (r->in.buffer) {
17796                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
17797                 }
17798         }
17799         if (flags & NDR_OUT) {
17800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17801                 if (_ptr_buffer) {
17802                         NDR_PULL_ALLOC(ndr, r->out.buffer);
17803                 } else {
17804                         r->out.buffer = NULL;
17805                 }
17806                 if (r->out.buffer) {
17807                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17808                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
17809                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
17810                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
17811                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
17812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17813                 }
17814                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17815                         NDR_PULL_ALLOC(ndr, r->out.needed);
17816                 }
17817                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17818                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17820                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17821                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17822                 if (r->out.buffer) {
17823                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
17824                 }
17825         }
17826         return NDR_ERR_SUCCESS;
17827 }
17828
17829 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
17830 {
17831         ndr_print_struct(ndr, name, "spoolss_AddJob");
17832         ndr->depth++;
17833         if (flags & NDR_SET_VALUES) {
17834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17835         }
17836         if (flags & NDR_IN) {
17837                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
17838                 ndr->depth++;
17839                 ndr_print_ptr(ndr, "handle", r->in.handle);
17840                 ndr->depth++;
17841                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17842                 ndr->depth--;
17843                 ndr_print_uint32(ndr, "level", r->in.level);
17844                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17845                 ndr->depth++;
17846                 if (r->in.buffer) {
17847                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
17848                 }
17849                 ndr->depth--;
17850                 ndr_print_uint32(ndr, "offered", r->in.offered);
17851                 ndr->depth--;
17852         }
17853         if (flags & NDR_OUT) {
17854                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
17855                 ndr->depth++;
17856                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
17857                 ndr->depth++;
17858                 if (r->out.buffer) {
17859                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
17860                 }
17861                 ndr->depth--;
17862                 ndr_print_ptr(ndr, "needed", r->out.needed);
17863                 ndr->depth++;
17864                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17865                 ndr->depth--;
17866                 ndr_print_WERROR(ndr, "result", r->out.result);
17867                 ndr->depth--;
17868         }
17869         ndr->depth--;
17870 }
17871
17872 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
17873 {
17874         if (flags & NDR_IN) {
17875                 if (r->in.handle == NULL) {
17876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17877                 }
17878                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
17880         }
17881         if (flags & NDR_OUT) {
17882                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17883         }
17884         return NDR_ERR_SUCCESS;
17885 }
17886
17887 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
17888 {
17889         TALLOC_CTX *_mem_save_handle_0;
17890         if (flags & NDR_IN) {
17891                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17892                         NDR_PULL_ALLOC(ndr, r->in.handle);
17893                 }
17894                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17895                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17896                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
17899         }
17900         if (flags & NDR_OUT) {
17901                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17902         }
17903         return NDR_ERR_SUCCESS;
17904 }
17905
17906 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
17907 {
17908         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
17909         ndr->depth++;
17910         if (flags & NDR_SET_VALUES) {
17911                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17912         }
17913         if (flags & NDR_IN) {
17914                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
17915                 ndr->depth++;
17916                 ndr_print_ptr(ndr, "handle", r->in.handle);
17917                 ndr->depth++;
17918                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17919                 ndr->depth--;
17920                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
17921                 ndr->depth--;
17922         }
17923         if (flags & NDR_OUT) {
17924                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
17925                 ndr->depth++;
17926                 ndr_print_WERROR(ndr, "result", r->out.result);
17927                 ndr->depth--;
17928         }
17929         ndr->depth--;
17930 }
17931
17932 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
17933 {
17934         if (flags & NDR_IN) {
17935                 if (r->in.handle == NULL) {
17936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17937                 }
17938                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17942                 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));
17943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17944         }
17945         if (flags & NDR_OUT) {
17946                 if (r->out.type == NULL) {
17947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17948                 }
17949                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
17950                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
17951                 if (r->out.needed == NULL) {
17952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17953                 }
17954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17955                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17956         }
17957         return NDR_ERR_SUCCESS;
17958 }
17959
17960 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
17961 {
17962         TALLOC_CTX *_mem_save_handle_0;
17963         TALLOC_CTX *_mem_save_type_0;
17964         TALLOC_CTX *_mem_save_needed_0;
17965         if (flags & NDR_IN) {
17966                 ZERO_STRUCT(r->out);
17967
17968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17969                         NDR_PULL_ALLOC(ndr, r->in.handle);
17970                 }
17971                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17972                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17973                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17975                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17976                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17977                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17978                         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));
17979                 }
17980                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17981                 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));
17982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17983                 NDR_PULL_ALLOC(ndr, r->out.type);
17984                 ZERO_STRUCTP(r->out.type);
17985                 NDR_PULL_ALLOC(ndr, r->out.needed);
17986                 ZERO_STRUCTP(r->out.needed);
17987         }
17988         if (flags & NDR_OUT) {
17989                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17990                         NDR_PULL_ALLOC(ndr, r->out.type);
17991                 }
17992                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
17993                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
17994                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
17995                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
17996                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
17997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17998                         NDR_PULL_ALLOC(ndr, r->out.needed);
17999                 }
18000                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18001                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18005         }
18006         return NDR_ERR_SUCCESS;
18007 }
18008
18009 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
18010 {
18011         if (flags & NDR_IN) {
18012                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
18013         }
18014         if (flags & NDR_OUT) {
18015                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
18016                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
18017         }
18018         return NDR_ERR_SUCCESS;
18019 }
18020
18021 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
18022 {
18023         if (flags & NDR_IN) {
18024                 ZERO_STRUCT(r->out);
18025
18026                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
18027         }
18028         if (flags & NDR_OUT) {
18029                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
18030                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
18031         }
18032         return NDR_ERR_SUCCESS;
18033 }
18034
18035 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
18036 {
18037         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
18038         ndr->depth++;
18039         if (flags & NDR_SET_VALUES) {
18040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18041         }
18042         if (flags & NDR_IN) {
18043                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
18044                 ndr->depth++;
18045                 ndr_print_ptr(ndr, "handle", r->in.handle);
18046                 ndr->depth++;
18047                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18048                 ndr->depth--;
18049                 ndr_print_string(ndr, "value_name", r->in.value_name);
18050                 ndr_print_uint32(ndr, "offered", r->in.offered);
18051                 ndr->depth--;
18052         }
18053         if (flags & NDR_OUT) {
18054                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
18055                 ndr->depth++;
18056                 ndr_print_ptr(ndr, "type", r->out.type);
18057                 ndr->depth++;
18058                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
18059                 ndr->depth--;
18060                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
18061                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
18062                 ndr_print_ptr(ndr, "needed", r->out.needed);
18063                 ndr->depth++;
18064                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18065                 ndr->depth--;
18066                 ndr_print_WERROR(ndr, "result", r->out.result);
18067                 ndr->depth--;
18068         }
18069         ndr->depth--;
18070 }
18071
18072 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
18073 {
18074         if (flags & NDR_IN) {
18075                 if (r->in.handle == NULL) {
18076                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18077                 }
18078                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
18080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
18082                 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));
18083                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
18084                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
18085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
18086         }
18087         if (flags & NDR_OUT) {
18088                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18089         }
18090         return NDR_ERR_SUCCESS;
18091 }
18092
18093 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
18094 {
18095         if (flags & NDR_IN) {
18096                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
18097         }
18098         if (flags & NDR_OUT) {
18099                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
18100                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
18101         }
18102         return NDR_ERR_SUCCESS;
18103 }
18104
18105 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
18106 {
18107         TALLOC_CTX *_mem_save_handle_0;
18108         if (flags & NDR_IN) {
18109                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18110                         NDR_PULL_ALLOC(ndr, r->in.handle);
18111                 }
18112                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18113                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18114                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18115                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18116                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
18117                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
18118                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
18119                         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));
18120                 }
18121                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
18122                 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));
18123                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
18124                 {
18125                         struct ndr_pull *_ndr_data;
18126                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
18127                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
18128                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
18129                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
18130                 }
18131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
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_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
18140 {
18141         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
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_SetPrinterData");
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, "value_name", r->in.value_name);
18154                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
18155                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
18156                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
18157                 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);
18158                 ndr->depth--;
18159         }
18160         if (flags & NDR_OUT) {
18161                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
18162                 ndr->depth++;
18163                 ndr_print_WERROR(ndr, "result", r->out.result);
18164                 ndr->depth--;
18165         }
18166         ndr->depth--;
18167 }
18168
18169 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
18170 {
18171         if (flags & NDR_IN) {
18172         }
18173         if (flags & NDR_OUT) {
18174                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18175         }
18176         return NDR_ERR_SUCCESS;
18177 }
18178
18179 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
18180 {
18181         if (flags & NDR_IN) {
18182         }
18183         if (flags & NDR_OUT) {
18184                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18185         }
18186         return NDR_ERR_SUCCESS;
18187 }
18188
18189 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
18190 {
18191         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
18192         ndr->depth++;
18193         if (flags & NDR_SET_VALUES) {
18194                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18195         }
18196         if (flags & NDR_IN) {
18197                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
18198                 ndr->depth++;
18199                 ndr->depth--;
18200         }
18201         if (flags & NDR_OUT) {
18202                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
18203                 ndr->depth++;
18204                 ndr_print_WERROR(ndr, "result", r->out.result);
18205                 ndr->depth--;
18206         }
18207         ndr->depth--;
18208 }
18209
18210 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
18211 {
18212         if (flags & NDR_IN) {
18213                 if (r->in.handle == NULL) {
18214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18215                 }
18216                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18217         }
18218         if (flags & NDR_OUT) {
18219                 if (r->out.handle == NULL) {
18220                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18221                 }
18222                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18223                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18224         }
18225         return NDR_ERR_SUCCESS;
18226 }
18227
18228 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
18229 {
18230         TALLOC_CTX *_mem_save_handle_0;
18231         if (flags & NDR_IN) {
18232                 ZERO_STRUCT(r->out);
18233
18234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18235                         NDR_PULL_ALLOC(ndr, r->in.handle);
18236                 }
18237                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18238                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18239                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18241                 NDR_PULL_ALLOC(ndr, r->out.handle);
18242                 *r->out.handle = *r->in.handle;
18243         }
18244         if (flags & NDR_OUT) {
18245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18246                         NDR_PULL_ALLOC(ndr, r->out.handle);
18247                 }
18248                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18249                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18253         }
18254         return NDR_ERR_SUCCESS;
18255 }
18256
18257 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
18258 {
18259         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
18260         ndr->depth++;
18261         if (flags & NDR_SET_VALUES) {
18262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18263         }
18264         if (flags & NDR_IN) {
18265                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
18266                 ndr->depth++;
18267                 ndr_print_ptr(ndr, "handle", r->in.handle);
18268                 ndr->depth++;
18269                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18270                 ndr->depth--;
18271                 ndr->depth--;
18272         }
18273         if (flags & NDR_OUT) {
18274                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
18275                 ndr->depth++;
18276                 ndr_print_ptr(ndr, "handle", r->out.handle);
18277                 ndr->depth++;
18278                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18279                 ndr->depth--;
18280                 ndr_print_WERROR(ndr, "result", r->out.result);
18281                 ndr->depth--;
18282         }
18283         ndr->depth--;
18284 }
18285
18286 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
18287 {
18288         if (flags & NDR_IN) {
18289                 if (r->in.handle == NULL) {
18290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18291                 }
18292                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18294                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18295                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18296         }
18297         if (flags & NDR_OUT) {
18298                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18299         }
18300         return NDR_ERR_SUCCESS;
18301 }
18302
18303 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
18304 {
18305         TALLOC_CTX *_mem_save_handle_0;
18306         if (flags & NDR_IN) {
18307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18308                         NDR_PULL_ALLOC(ndr, r->in.handle);
18309                 }
18310                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18311                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18312                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18315                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18316                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18317         }
18318         if (flags & NDR_OUT) {
18319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18320         }
18321         return NDR_ERR_SUCCESS;
18322 }
18323
18324 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
18325 {
18326         ndr_print_struct(ndr, name, "spoolss_AddForm");
18327         ndr->depth++;
18328         if (flags & NDR_SET_VALUES) {
18329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18330         }
18331         if (flags & NDR_IN) {
18332                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
18333                 ndr->depth++;
18334                 ndr_print_ptr(ndr, "handle", r->in.handle);
18335                 ndr->depth++;
18336                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18337                 ndr->depth--;
18338                 ndr_print_uint32(ndr, "level", r->in.level);
18339                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18340                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18341                 ndr->depth--;
18342         }
18343         if (flags & NDR_OUT) {
18344                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
18345                 ndr->depth++;
18346                 ndr_print_WERROR(ndr, "result", r->out.result);
18347                 ndr->depth--;
18348         }
18349         ndr->depth--;
18350 }
18351
18352 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
18353 {
18354         if (flags & NDR_IN) {
18355                 if (r->in.handle == NULL) {
18356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18357                 }
18358                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18362                 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));
18363         }
18364         if (flags & NDR_OUT) {
18365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18366         }
18367         return NDR_ERR_SUCCESS;
18368 }
18369
18370 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
18371 {
18372         TALLOC_CTX *_mem_save_handle_0;
18373         if (flags & NDR_IN) {
18374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18375                         NDR_PULL_ALLOC(ndr, r->in.handle);
18376                 }
18377                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18378                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18379                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18381                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18382                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18383                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18384                         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));
18385                 }
18386                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18387                 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));
18388         }
18389         if (flags & NDR_OUT) {
18390                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18391         }
18392         return NDR_ERR_SUCCESS;
18393 }
18394
18395 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
18396 {
18397         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
18398         ndr->depth++;
18399         if (flags & NDR_SET_VALUES) {
18400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18401         }
18402         if (flags & NDR_IN) {
18403                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
18404                 ndr->depth++;
18405                 ndr_print_ptr(ndr, "handle", r->in.handle);
18406                 ndr->depth++;
18407                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18408                 ndr->depth--;
18409                 ndr_print_string(ndr, "form_name", r->in.form_name);
18410                 ndr->depth--;
18411         }
18412         if (flags & NDR_OUT) {
18413                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
18414                 ndr->depth++;
18415                 ndr_print_WERROR(ndr, "result", r->out.result);
18416                 ndr->depth--;
18417         }
18418         ndr->depth--;
18419 }
18420
18421 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
18422 {
18423         if (flags & NDR_IN) {
18424                 if (r->in.handle == NULL) {
18425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18426                 }
18427                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18431                 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));
18432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18434                 if (r->in.buffer) {
18435                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18436                 }
18437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18438         }
18439         if (flags & NDR_OUT) {
18440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18441                 if (r->out.info) {
18442                         {
18443                                 struct ndr_push *_ndr_info;
18444                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18445                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18446                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18447                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18448                         }
18449                 }
18450                 if (r->out.needed == NULL) {
18451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18452                 }
18453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18454                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18455         }
18456         return NDR_ERR_SUCCESS;
18457 }
18458
18459 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
18460 {
18461         uint32_t _ptr_buffer;
18462         uint32_t _ptr_info;
18463         TALLOC_CTX *_mem_save_handle_0;
18464         TALLOC_CTX *_mem_save_buffer_0;
18465         TALLOC_CTX *_mem_save_info_0;
18466         TALLOC_CTX *_mem_save_needed_0;
18467         if (flags & NDR_IN) {
18468                 ZERO_STRUCT(r->out);
18469
18470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18471                         NDR_PULL_ALLOC(ndr, r->in.handle);
18472                 }
18473                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18474                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18475                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18477                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18478                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18479                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18480                         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));
18481                 }
18482                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18483                 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));
18484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18486                 if (_ptr_buffer) {
18487                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18488                 } else {
18489                         r->in.buffer = NULL;
18490                 }
18491                 if (r->in.buffer) {
18492                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18493                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18494                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18496                 }
18497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18498                 NDR_PULL_ALLOC(ndr, r->out.needed);
18499                 ZERO_STRUCTP(r->out.needed);
18500         }
18501         if (flags & NDR_OUT) {
18502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18503                 if (_ptr_info) {
18504                         NDR_PULL_ALLOC(ndr, r->out.info);
18505                 } else {
18506                         r->out.info = NULL;
18507                 }
18508                 if (r->out.info) {
18509                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18510                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18511                         {
18512                                 struct ndr_pull *_ndr_info;
18513                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18514                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18515                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18516                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18517                         }
18518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18519                 }
18520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18521                         NDR_PULL_ALLOC(ndr, r->out.needed);
18522                 }
18523                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18524                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18527                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18528         }
18529         return NDR_ERR_SUCCESS;
18530 }
18531
18532 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
18533 {
18534         ndr_print_struct(ndr, name, "spoolss_GetForm");
18535         ndr->depth++;
18536         if (flags & NDR_SET_VALUES) {
18537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18538         }
18539         if (flags & NDR_IN) {
18540                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
18541                 ndr->depth++;
18542                 ndr_print_ptr(ndr, "handle", r->in.handle);
18543                 ndr->depth++;
18544                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18545                 ndr->depth--;
18546                 ndr_print_string(ndr, "form_name", r->in.form_name);
18547                 ndr_print_uint32(ndr, "level", r->in.level);
18548                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18549                 ndr->depth++;
18550                 if (r->in.buffer) {
18551                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18552                 }
18553                 ndr->depth--;
18554                 ndr_print_uint32(ndr, "offered", r->in.offered);
18555                 ndr->depth--;
18556         }
18557         if (flags & NDR_OUT) {
18558                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
18559                 ndr->depth++;
18560                 ndr_print_ptr(ndr, "info", r->out.info);
18561                 ndr->depth++;
18562                 if (r->out.info) {
18563                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18564                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
18565                 }
18566                 ndr->depth--;
18567                 ndr_print_ptr(ndr, "needed", r->out.needed);
18568                 ndr->depth++;
18569                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18570                 ndr->depth--;
18571                 ndr_print_WERROR(ndr, "result", r->out.result);
18572                 ndr->depth--;
18573         }
18574         ndr->depth--;
18575 }
18576
18577 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
18578 {
18579         if (flags & NDR_IN) {
18580                 if (r->in.handle == NULL) {
18581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18582                 }
18583                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18587                 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));
18588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18589                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18590                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18591         }
18592         if (flags & NDR_OUT) {
18593                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18594         }
18595         return NDR_ERR_SUCCESS;
18596 }
18597
18598 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
18599 {
18600         TALLOC_CTX *_mem_save_handle_0;
18601         if (flags & NDR_IN) {
18602                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18603                         NDR_PULL_ALLOC(ndr, r->in.handle);
18604                 }
18605                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18606                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18607                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18608                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18609                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18610                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18611                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18612                         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));
18613                 }
18614                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18615                 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));
18616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18617                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18618                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18619         }
18620         if (flags & NDR_OUT) {
18621                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18622         }
18623         return NDR_ERR_SUCCESS;
18624 }
18625
18626 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
18627 {
18628         ndr_print_struct(ndr, name, "spoolss_SetForm");
18629         ndr->depth++;
18630         if (flags & NDR_SET_VALUES) {
18631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18632         }
18633         if (flags & NDR_IN) {
18634                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
18635                 ndr->depth++;
18636                 ndr_print_ptr(ndr, "handle", r->in.handle);
18637                 ndr->depth++;
18638                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18639                 ndr->depth--;
18640                 ndr_print_string(ndr, "form_name", r->in.form_name);
18641                 ndr_print_uint32(ndr, "level", r->in.level);
18642                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18643                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18644                 ndr->depth--;
18645         }
18646         if (flags & NDR_OUT) {
18647                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
18648                 ndr->depth++;
18649                 ndr_print_WERROR(ndr, "result", r->out.result);
18650                 ndr->depth--;
18651         }
18652         ndr->depth--;
18653 }
18654
18655 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
18656 {
18657         if (flags & NDR_IN) {
18658                 if (r->in.handle == NULL) {
18659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18660                 }
18661                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18664                 if (r->in.buffer) {
18665                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18666                 }
18667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18668         }
18669         if (flags & NDR_OUT) {
18670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18671                 if (r->out.info) {
18672                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18673                 }
18674                 if (r->out.needed == NULL) {
18675                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18676                 }
18677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18678                 if (r->out.count == NULL) {
18679                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18680                 }
18681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18682                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18683         }
18684         return NDR_ERR_SUCCESS;
18685 }
18686
18687 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
18688 {
18689         uint32_t _ptr_buffer;
18690         uint32_t _ptr_info;
18691         TALLOC_CTX *_mem_save_handle_0;
18692         TALLOC_CTX *_mem_save_buffer_0;
18693         TALLOC_CTX *_mem_save_info_0;
18694         TALLOC_CTX *_mem_save_needed_0;
18695         TALLOC_CTX *_mem_save_count_0;
18696         if (flags & NDR_IN) {
18697                 ZERO_STRUCT(r->out);
18698
18699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18700                         NDR_PULL_ALLOC(ndr, r->in.handle);
18701                 }
18702                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18703                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18704                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18708                 if (_ptr_buffer) {
18709                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18710                 } else {
18711                         r->in.buffer = NULL;
18712                 }
18713                 if (r->in.buffer) {
18714                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18715                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18716                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18718                 }
18719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18720                 NDR_PULL_ALLOC(ndr, r->out.needed);
18721                 ZERO_STRUCTP(r->out.needed);
18722                 NDR_PULL_ALLOC(ndr, r->out.count);
18723                 ZERO_STRUCTP(r->out.count);
18724         }
18725         if (flags & NDR_OUT) {
18726                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18727                 if (_ptr_info) {
18728                         NDR_PULL_ALLOC(ndr, r->out.info);
18729                 } else {
18730                         r->out.info = NULL;
18731                 }
18732                 if (r->out.info) {
18733                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18734                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18735                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18737                 }
18738                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18739                         NDR_PULL_ALLOC(ndr, r->out.needed);
18740                 }
18741                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18742                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18744                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18745                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18746                         NDR_PULL_ALLOC(ndr, r->out.count);
18747                 }
18748                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18749                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18753         }
18754         return NDR_ERR_SUCCESS;
18755 }
18756
18757 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
18758 {
18759         uint32_t cntr_info_0;
18760         if (flags & NDR_IN) {
18761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18763         }
18764         if (flags & NDR_OUT) {
18765                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18766                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18767                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18768                 }
18769                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18770                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18771                 }
18772         }
18773         return NDR_ERR_SUCCESS;
18774 }
18775
18776 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
18777 {
18778         uint32_t cntr_info_0;
18779         TALLOC_CTX *_mem_save_info_0;
18780         if (flags & NDR_IN) {
18781                 ZERO_STRUCT(r->out);
18782
18783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18785         }
18786         if (flags & NDR_OUT) {
18787                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18788                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18789                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18790                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18791                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18792                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18793                 }
18794                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18795                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18796                 }
18797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18798         }
18799         return NDR_ERR_SUCCESS;
18800 }
18801
18802 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
18803 {
18804         uint32_t cntr_info_1;
18805         ndr_print_struct(ndr, name, "spoolss_EnumForms");
18806         ndr->depth++;
18807         if (flags & NDR_SET_VALUES) {
18808                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18809         }
18810         if (flags & NDR_IN) {
18811                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
18812                 ndr->depth++;
18813                 ndr_print_ptr(ndr, "handle", r->in.handle);
18814                 ndr->depth++;
18815                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18816                 ndr->depth--;
18817                 ndr_print_uint32(ndr, "level", r->in.level);
18818                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18819                 ndr->depth++;
18820                 if (r->in.buffer) {
18821                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18822                 }
18823                 ndr->depth--;
18824                 ndr_print_uint32(ndr, "offered", r->in.offered);
18825                 ndr->depth--;
18826         }
18827         if (flags & NDR_OUT) {
18828                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
18829                 ndr->depth++;
18830                 ndr_print_ptr(ndr, "count", r->out.count);
18831                 ndr->depth++;
18832                 ndr_print_uint32(ndr, "count", *r->out.count);
18833                 ndr->depth--;
18834                 ndr_print_ptr(ndr, "info", r->out.info);
18835                 ndr->depth++;
18836                 if (r->out.info) {
18837                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18838                         ndr->depth++;
18839                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18840                                 char *idx_1=NULL;
18841                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18842                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18843                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
18844                                         free(idx_1);
18845                                 }
18846                         }
18847                         ndr->depth--;
18848                 }
18849                 ndr->depth--;
18850                 ndr_print_ptr(ndr, "needed", r->out.needed);
18851                 ndr->depth++;
18852                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18853                 ndr->depth--;
18854                 ndr_print_WERROR(ndr, "result", r->out.result);
18855                 ndr->depth--;
18856         }
18857         ndr->depth--;
18858 }
18859
18860 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
18861 {
18862         if (flags & NDR_IN) {
18863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18864                 if (r->in.servername) {
18865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18867                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18868                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18869                 }
18870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18872                 if (r->in.buffer) {
18873                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18874                 }
18875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18876         }
18877         if (flags & NDR_OUT) {
18878                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18879                 if (r->out.info) {
18880                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18881                 }
18882                 if (r->out.needed == NULL) {
18883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18884                 }
18885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18886                 if (r->out.count == NULL) {
18887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18888                 }
18889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18891         }
18892         return NDR_ERR_SUCCESS;
18893 }
18894
18895 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
18896 {
18897         uint32_t _ptr_servername;
18898         uint32_t _ptr_buffer;
18899         uint32_t _ptr_info;
18900         TALLOC_CTX *_mem_save_servername_0;
18901         TALLOC_CTX *_mem_save_buffer_0;
18902         TALLOC_CTX *_mem_save_info_0;
18903         TALLOC_CTX *_mem_save_needed_0;
18904         TALLOC_CTX *_mem_save_count_0;
18905         if (flags & NDR_IN) {
18906                 ZERO_STRUCT(r->out);
18907
18908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18909                 if (_ptr_servername) {
18910                         NDR_PULL_ALLOC(ndr, r->in.servername);
18911                 } else {
18912                         r->in.servername = NULL;
18913                 }
18914                 if (r->in.servername) {
18915                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18916                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18919                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18920                                 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));
18921                         }
18922                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18923                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18925                 }
18926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18928                 if (_ptr_buffer) {
18929                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18930                 } else {
18931                         r->in.buffer = NULL;
18932                 }
18933                 if (r->in.buffer) {
18934                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18935                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18936                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18938                 }
18939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18940                 NDR_PULL_ALLOC(ndr, r->out.needed);
18941                 ZERO_STRUCTP(r->out.needed);
18942                 NDR_PULL_ALLOC(ndr, r->out.count);
18943                 ZERO_STRUCTP(r->out.count);
18944         }
18945         if (flags & NDR_OUT) {
18946                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18947                 if (_ptr_info) {
18948                         NDR_PULL_ALLOC(ndr, r->out.info);
18949                 } else {
18950                         r->out.info = NULL;
18951                 }
18952                 if (r->out.info) {
18953                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18954                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18955                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18957                 }
18958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18959                         NDR_PULL_ALLOC(ndr, r->out.needed);
18960                 }
18961                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18962                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18965                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18966                         NDR_PULL_ALLOC(ndr, r->out.count);
18967                 }
18968                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18969                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18972                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18973         }
18974         return NDR_ERR_SUCCESS;
18975 }
18976
18977 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
18978 {
18979         uint32_t cntr_info_0;
18980         if (flags & NDR_IN) {
18981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18983         }
18984         if (flags & NDR_OUT) {
18985                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18986                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18987                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18988                 }
18989                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18990                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18991                 }
18992         }
18993         return NDR_ERR_SUCCESS;
18994 }
18995
18996 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
18997 {
18998         uint32_t cntr_info_0;
18999         TALLOC_CTX *_mem_save_info_0;
19000         if (flags & NDR_IN) {
19001                 ZERO_STRUCT(r->out);
19002
19003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19005         }
19006         if (flags & NDR_OUT) {
19007                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19008                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19009                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19010                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19011                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19012                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19013                 }
19014                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19015                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19016                 }
19017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19018         }
19019         return NDR_ERR_SUCCESS;
19020 }
19021
19022 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
19023 {
19024         uint32_t cntr_info_1;
19025         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
19026         ndr->depth++;
19027         if (flags & NDR_SET_VALUES) {
19028                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19029         }
19030         if (flags & NDR_IN) {
19031                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
19032                 ndr->depth++;
19033                 ndr_print_ptr(ndr, "servername", r->in.servername);
19034                 ndr->depth++;
19035                 if (r->in.servername) {
19036                         ndr_print_string(ndr, "servername", r->in.servername);
19037                 }
19038                 ndr->depth--;
19039                 ndr_print_uint32(ndr, "level", r->in.level);
19040                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19041                 ndr->depth++;
19042                 if (r->in.buffer) {
19043                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19044                 }
19045                 ndr->depth--;
19046                 ndr_print_uint32(ndr, "offered", r->in.offered);
19047                 ndr->depth--;
19048         }
19049         if (flags & NDR_OUT) {
19050                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
19051                 ndr->depth++;
19052                 ndr_print_ptr(ndr, "count", r->out.count);
19053                 ndr->depth++;
19054                 ndr_print_uint32(ndr, "count", *r->out.count);
19055                 ndr->depth--;
19056                 ndr_print_ptr(ndr, "info", r->out.info);
19057                 ndr->depth++;
19058                 if (r->out.info) {
19059                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19060                         ndr->depth++;
19061                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19062                                 char *idx_1=NULL;
19063                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19064                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
19065                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
19066                                         free(idx_1);
19067                                 }
19068                         }
19069                         ndr->depth--;
19070                 }
19071                 ndr->depth--;
19072                 ndr_print_ptr(ndr, "needed", r->out.needed);
19073                 ndr->depth++;
19074                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19075                 ndr->depth--;
19076                 ndr_print_WERROR(ndr, "result", r->out.result);
19077                 ndr->depth--;
19078         }
19079         ndr->depth--;
19080 }
19081
19082 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
19083 {
19084         if (flags & NDR_IN) {
19085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19086                 if (r->in.servername) {
19087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19091                 }
19092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19094                 if (r->in.buffer) {
19095                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19096                 }
19097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19098         }
19099         if (flags & NDR_OUT) {
19100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19101                 if (r->out.info) {
19102                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19103                 }
19104                 if (r->out.needed == NULL) {
19105                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19106                 }
19107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19108                 if (r->out.count == NULL) {
19109                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19110                 }
19111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19112                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19113         }
19114         return NDR_ERR_SUCCESS;
19115 }
19116
19117 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
19118 {
19119         uint32_t _ptr_servername;
19120         uint32_t _ptr_buffer;
19121         uint32_t _ptr_info;
19122         TALLOC_CTX *_mem_save_servername_0;
19123         TALLOC_CTX *_mem_save_buffer_0;
19124         TALLOC_CTX *_mem_save_info_0;
19125         TALLOC_CTX *_mem_save_needed_0;
19126         TALLOC_CTX *_mem_save_count_0;
19127         if (flags & NDR_IN) {
19128                 ZERO_STRUCT(r->out);
19129
19130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19131                 if (_ptr_servername) {
19132                         NDR_PULL_ALLOC(ndr, r->in.servername);
19133                 } else {
19134                         r->in.servername = NULL;
19135                 }
19136                 if (r->in.servername) {
19137                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19138                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19141                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19142                                 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));
19143                         }
19144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19147                 }
19148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19150                 if (_ptr_buffer) {
19151                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19152                 } else {
19153                         r->in.buffer = NULL;
19154                 }
19155                 if (r->in.buffer) {
19156                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19157                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19158                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19160                 }
19161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19162                 NDR_PULL_ALLOC(ndr, r->out.needed);
19163                 ZERO_STRUCTP(r->out.needed);
19164                 NDR_PULL_ALLOC(ndr, r->out.count);
19165                 ZERO_STRUCTP(r->out.count);
19166         }
19167         if (flags & NDR_OUT) {
19168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19169                 if (_ptr_info) {
19170                         NDR_PULL_ALLOC(ndr, r->out.info);
19171                 } else {
19172                         r->out.info = NULL;
19173                 }
19174                 if (r->out.info) {
19175                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19176                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19177                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19179                 }
19180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19181                         NDR_PULL_ALLOC(ndr, r->out.needed);
19182                 }
19183                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19188                         NDR_PULL_ALLOC(ndr, r->out.count);
19189                 }
19190                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19191                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19195         }
19196         return NDR_ERR_SUCCESS;
19197 }
19198
19199 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
19200 {
19201         uint32_t cntr_info_0;
19202         if (flags & NDR_IN) {
19203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19205         }
19206         if (flags & NDR_OUT) {
19207                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19208                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19209                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19210                 }
19211                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19212                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19213                 }
19214         }
19215         return NDR_ERR_SUCCESS;
19216 }
19217
19218 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
19219 {
19220         uint32_t cntr_info_0;
19221         TALLOC_CTX *_mem_save_info_0;
19222         if (flags & NDR_IN) {
19223                 ZERO_STRUCT(r->out);
19224
19225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19227         }
19228         if (flags & NDR_OUT) {
19229                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19230                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19231                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19232                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19233                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19234                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19235                 }
19236                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19237                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19238                 }
19239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19240         }
19241         return NDR_ERR_SUCCESS;
19242 }
19243
19244 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
19245 {
19246         uint32_t cntr_info_1;
19247         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
19248         ndr->depth++;
19249         if (flags & NDR_SET_VALUES) {
19250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19251         }
19252         if (flags & NDR_IN) {
19253                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
19254                 ndr->depth++;
19255                 ndr_print_ptr(ndr, "servername", r->in.servername);
19256                 ndr->depth++;
19257                 if (r->in.servername) {
19258                         ndr_print_string(ndr, "servername", r->in.servername);
19259                 }
19260                 ndr->depth--;
19261                 ndr_print_uint32(ndr, "level", r->in.level);
19262                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19263                 ndr->depth++;
19264                 if (r->in.buffer) {
19265                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19266                 }
19267                 ndr->depth--;
19268                 ndr_print_uint32(ndr, "offered", r->in.offered);
19269                 ndr->depth--;
19270         }
19271         if (flags & NDR_OUT) {
19272                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
19273                 ndr->depth++;
19274                 ndr_print_ptr(ndr, "count", r->out.count);
19275                 ndr->depth++;
19276                 ndr_print_uint32(ndr, "count", *r->out.count);
19277                 ndr->depth--;
19278                 ndr_print_ptr(ndr, "info", r->out.info);
19279                 ndr->depth++;
19280                 if (r->out.info) {
19281                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19282                         ndr->depth++;
19283                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19284                                 char *idx_1=NULL;
19285                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19286                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
19287                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
19288                                         free(idx_1);
19289                                 }
19290                         }
19291                         ndr->depth--;
19292                 }
19293                 ndr->depth--;
19294                 ndr_print_ptr(ndr, "needed", r->out.needed);
19295                 ndr->depth++;
19296                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19297                 ndr->depth--;
19298                 ndr_print_WERROR(ndr, "result", r->out.result);
19299                 ndr->depth--;
19300         }
19301         ndr->depth--;
19302 }
19303
19304 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
19305 {
19306         if (flags & NDR_IN) {
19307                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
19308                 if (r->in.server_name) {
19309                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19310                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19312                         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));
19313                 }
19314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
19315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
19318                 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));
19319         }
19320         if (flags & NDR_OUT) {
19321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19322         }
19323         return NDR_ERR_SUCCESS;
19324 }
19325
19326 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
19327 {
19328         uint32_t _ptr_server_name;
19329         TALLOC_CTX *_mem_save_server_name_0;
19330         if (flags & NDR_IN) {
19331                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
19332                 if (_ptr_server_name) {
19333                         NDR_PULL_ALLOC(ndr, r->in.server_name);
19334                 } else {
19335                         r->in.server_name = NULL;
19336                 }
19337                 if (r->in.server_name) {
19338                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19339                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
19340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
19341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
19342                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
19343                                 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));
19344                         }
19345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
19346                         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));
19347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
19348                 }
19349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
19350                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
19351                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
19352                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
19353                         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));
19354                 }
19355                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
19356                 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));
19357         }
19358         if (flags & NDR_OUT) {
19359                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19360         }
19361         return NDR_ERR_SUCCESS;
19362 }
19363
19364 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
19365 {
19366         ndr_print_struct(ndr, name, "spoolss_AddPort");
19367         ndr->depth++;
19368         if (flags & NDR_SET_VALUES) {
19369                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19370         }
19371         if (flags & NDR_IN) {
19372                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
19373                 ndr->depth++;
19374                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
19375                 ndr->depth++;
19376                 if (r->in.server_name) {
19377                         ndr_print_string(ndr, "server_name", r->in.server_name);
19378                 }
19379                 ndr->depth--;
19380                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
19381                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
19382                 ndr->depth--;
19383         }
19384         if (flags & NDR_OUT) {
19385                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
19386                 ndr->depth++;
19387                 ndr_print_WERROR(ndr, "result", r->out.result);
19388                 ndr->depth--;
19389         }
19390         ndr->depth--;
19391 }
19392
19393 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
19394 {
19395         if (flags & NDR_IN) {
19396         }
19397         if (flags & NDR_OUT) {
19398                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19399         }
19400         return NDR_ERR_SUCCESS;
19401 }
19402
19403 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
19404 {
19405         if (flags & NDR_IN) {
19406         }
19407         if (flags & NDR_OUT) {
19408                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19409         }
19410         return NDR_ERR_SUCCESS;
19411 }
19412
19413 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
19414 {
19415         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
19416         ndr->depth++;
19417         if (flags & NDR_SET_VALUES) {
19418                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19419         }
19420         if (flags & NDR_IN) {
19421                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
19422                 ndr->depth++;
19423                 ndr->depth--;
19424         }
19425         if (flags & NDR_OUT) {
19426                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
19427                 ndr->depth++;
19428                 ndr_print_WERROR(ndr, "result", r->out.result);
19429                 ndr->depth--;
19430         }
19431         ndr->depth--;
19432 }
19433
19434 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
19435 {
19436         if (flags & NDR_IN) {
19437         }
19438         if (flags & NDR_OUT) {
19439                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19440         }
19441         return NDR_ERR_SUCCESS;
19442 }
19443
19444 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
19445 {
19446         if (flags & NDR_IN) {
19447         }
19448         if (flags & NDR_OUT) {
19449                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19450         }
19451         return NDR_ERR_SUCCESS;
19452 }
19453
19454 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
19455 {
19456         ndr_print_struct(ndr, name, "spoolss_DeletePort");
19457         ndr->depth++;
19458         if (flags & NDR_SET_VALUES) {
19459                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19460         }
19461         if (flags & NDR_IN) {
19462                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
19463                 ndr->depth++;
19464                 ndr->depth--;
19465         }
19466         if (flags & NDR_OUT) {
19467                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
19468                 ndr->depth++;
19469                 ndr_print_WERROR(ndr, "result", r->out.result);
19470                 ndr->depth--;
19471         }
19472         ndr->depth--;
19473 }
19474
19475 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
19476 {
19477         if (flags & NDR_IN) {
19478         }
19479         if (flags & NDR_OUT) {
19480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19481         }
19482         return NDR_ERR_SUCCESS;
19483 }
19484
19485 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
19486 {
19487         if (flags & NDR_IN) {
19488         }
19489         if (flags & NDR_OUT) {
19490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19491         }
19492         return NDR_ERR_SUCCESS;
19493 }
19494
19495 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
19496 {
19497         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
19498         ndr->depth++;
19499         if (flags & NDR_SET_VALUES) {
19500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19501         }
19502         if (flags & NDR_IN) {
19503                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
19504                 ndr->depth++;
19505                 ndr->depth--;
19506         }
19507         if (flags & NDR_OUT) {
19508                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
19509                 ndr->depth++;
19510                 ndr_print_WERROR(ndr, "result", r->out.result);
19511                 ndr->depth--;
19512         }
19513         ndr->depth--;
19514 }
19515
19516 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19517 {
19518         if (flags & NDR_IN) {
19519         }
19520         if (flags & NDR_OUT) {
19521                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19522         }
19523         return NDR_ERR_SUCCESS;
19524 }
19525
19526 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
19527 {
19528         if (flags & NDR_IN) {
19529         }
19530         if (flags & NDR_OUT) {
19531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19532         }
19533         return NDR_ERR_SUCCESS;
19534 }
19535
19536 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
19537 {
19538         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
19539         ndr->depth++;
19540         if (flags & NDR_SET_VALUES) {
19541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19542         }
19543         if (flags & NDR_IN) {
19544                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
19545                 ndr->depth++;
19546                 ndr->depth--;
19547         }
19548         if (flags & NDR_OUT) {
19549                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
19550                 ndr->depth++;
19551                 ndr_print_WERROR(ndr, "result", r->out.result);
19552                 ndr->depth--;
19553         }
19554         ndr->depth--;
19555 }
19556
19557 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
19558 {
19559         if (flags & NDR_IN) {
19560         }
19561         if (flags & NDR_OUT) {
19562                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19563         }
19564         return NDR_ERR_SUCCESS;
19565 }
19566
19567 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
19568 {
19569         if (flags & NDR_IN) {
19570         }
19571         if (flags & NDR_OUT) {
19572                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19573         }
19574         return NDR_ERR_SUCCESS;
19575 }
19576
19577 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
19578 {
19579         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
19580         ndr->depth++;
19581         if (flags & NDR_SET_VALUES) {
19582                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19583         }
19584         if (flags & NDR_IN) {
19585                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
19586                 ndr->depth++;
19587                 ndr->depth--;
19588         }
19589         if (flags & NDR_OUT) {
19590                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
19591                 ndr->depth++;
19592                 ndr_print_WERROR(ndr, "result", r->out.result);
19593                 ndr->depth--;
19594         }
19595         ndr->depth--;
19596 }
19597
19598 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
19599 {
19600         if (flags & NDR_IN) {
19601         }
19602         if (flags & NDR_OUT) {
19603                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19604         }
19605         return NDR_ERR_SUCCESS;
19606 }
19607
19608 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
19609 {
19610         if (flags & NDR_IN) {
19611         }
19612         if (flags & NDR_OUT) {
19613                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19614         }
19615         return NDR_ERR_SUCCESS;
19616 }
19617
19618 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
19619 {
19620         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
19621         ndr->depth++;
19622         if (flags & NDR_SET_VALUES) {
19623                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19624         }
19625         if (flags & NDR_IN) {
19626                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
19627                 ndr->depth++;
19628                 ndr->depth--;
19629         }
19630         if (flags & NDR_OUT) {
19631                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
19632                 ndr->depth++;
19633                 ndr_print_WERROR(ndr, "result", r->out.result);
19634                 ndr->depth--;
19635         }
19636         ndr->depth--;
19637 }
19638
19639 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
19640 {
19641         if (flags & NDR_IN) {
19642         }
19643         if (flags & NDR_OUT) {
19644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19645         }
19646         return NDR_ERR_SUCCESS;
19647 }
19648
19649 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
19650 {
19651         if (flags & NDR_IN) {
19652         }
19653         if (flags & NDR_OUT) {
19654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19655         }
19656         return NDR_ERR_SUCCESS;
19657 }
19658
19659 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
19660 {
19661         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
19662         ndr->depth++;
19663         if (flags & NDR_SET_VALUES) {
19664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19665         }
19666         if (flags & NDR_IN) {
19667                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
19668                 ndr->depth++;
19669                 ndr->depth--;
19670         }
19671         if (flags & NDR_OUT) {
19672                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
19673                 ndr->depth++;
19674                 ndr_print_WERROR(ndr, "result", r->out.result);
19675                 ndr->depth--;
19676         }
19677         ndr->depth--;
19678 }
19679
19680 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
19681 {
19682         if (flags & NDR_IN) {
19683         }
19684         if (flags & NDR_OUT) {
19685                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19686         }
19687         return NDR_ERR_SUCCESS;
19688 }
19689
19690 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
19691 {
19692         if (flags & NDR_IN) {
19693         }
19694         if (flags & NDR_OUT) {
19695                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19696         }
19697         return NDR_ERR_SUCCESS;
19698 }
19699
19700 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
19701 {
19702         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
19703         ndr->depth++;
19704         if (flags & NDR_SET_VALUES) {
19705                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19706         }
19707         if (flags & NDR_IN) {
19708                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
19709                 ndr->depth++;
19710                 ndr->depth--;
19711         }
19712         if (flags & NDR_OUT) {
19713                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
19714                 ndr->depth++;
19715                 ndr_print_WERROR(ndr, "result", r->out.result);
19716                 ndr->depth--;
19717         }
19718         ndr->depth--;
19719 }
19720
19721 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
19722 {
19723         if (flags & NDR_IN) {
19724         }
19725         if (flags & NDR_OUT) {
19726                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19727         }
19728         return NDR_ERR_SUCCESS;
19729 }
19730
19731 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
19732 {
19733         if (flags & NDR_IN) {
19734         }
19735         if (flags & NDR_OUT) {
19736                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19737         }
19738         return NDR_ERR_SUCCESS;
19739 }
19740
19741 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
19742 {
19743         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
19744         ndr->depth++;
19745         if (flags & NDR_SET_VALUES) {
19746                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19747         }
19748         if (flags & NDR_IN) {
19749                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
19750                 ndr->depth++;
19751                 ndr->depth--;
19752         }
19753         if (flags & NDR_OUT) {
19754                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
19755                 ndr->depth++;
19756                 ndr_print_WERROR(ndr, "result", r->out.result);
19757                 ndr->depth--;
19758         }
19759         ndr->depth--;
19760 }
19761
19762 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
19763 {
19764         if (flags & NDR_IN) {
19765         }
19766         if (flags & NDR_OUT) {
19767                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19768         }
19769         return NDR_ERR_SUCCESS;
19770 }
19771
19772 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
19773 {
19774         if (flags & NDR_IN) {
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_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
19783 {
19784         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
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_DeleteMonitor");
19791                 ndr->depth++;
19792                 ndr->depth--;
19793         }
19794         if (flags & NDR_OUT) {
19795                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
19796                 ndr->depth++;
19797                 ndr_print_WERROR(ndr, "result", r->out.result);
19798                 ndr->depth--;
19799         }
19800         ndr->depth--;
19801 }
19802
19803 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
19804 {
19805         if (flags & NDR_IN) {
19806         }
19807         if (flags & NDR_OUT) {
19808                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19809         }
19810         return NDR_ERR_SUCCESS;
19811 }
19812
19813 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
19814 {
19815         if (flags & NDR_IN) {
19816         }
19817         if (flags & NDR_OUT) {
19818                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19819         }
19820         return NDR_ERR_SUCCESS;
19821 }
19822
19823 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
19824 {
19825         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
19826         ndr->depth++;
19827         if (flags & NDR_SET_VALUES) {
19828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19829         }
19830         if (flags & NDR_IN) {
19831                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
19832                 ndr->depth++;
19833                 ndr->depth--;
19834         }
19835         if (flags & NDR_OUT) {
19836                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
19837                 ndr->depth++;
19838                 ndr_print_WERROR(ndr, "result", r->out.result);
19839                 ndr->depth--;
19840         }
19841         ndr->depth--;
19842 }
19843
19844 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
19845 {
19846         if (flags & NDR_IN) {
19847         }
19848         if (flags & NDR_OUT) {
19849                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19850         }
19851         return NDR_ERR_SUCCESS;
19852 }
19853
19854 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
19855 {
19856         if (flags & NDR_IN) {
19857         }
19858         if (flags & NDR_OUT) {
19859                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19860         }
19861         return NDR_ERR_SUCCESS;
19862 }
19863
19864 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
19865 {
19866         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
19867         ndr->depth++;
19868         if (flags & NDR_SET_VALUES) {
19869                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19870         }
19871         if (flags & NDR_IN) {
19872                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
19873                 ndr->depth++;
19874                 ndr->depth--;
19875         }
19876         if (flags & NDR_OUT) {
19877                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
19878                 ndr->depth++;
19879                 ndr_print_WERROR(ndr, "result", r->out.result);
19880                 ndr->depth--;
19881         }
19882         ndr->depth--;
19883 }
19884
19885 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
19886 {
19887         if (flags & NDR_IN) {
19888         }
19889         if (flags & NDR_OUT) {
19890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19891         }
19892         return NDR_ERR_SUCCESS;
19893 }
19894
19895 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
19896 {
19897         if (flags & NDR_IN) {
19898         }
19899         if (flags & NDR_OUT) {
19900                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19901         }
19902         return NDR_ERR_SUCCESS;
19903 }
19904
19905 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
19906 {
19907         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
19908         ndr->depth++;
19909         if (flags & NDR_SET_VALUES) {
19910                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19911         }
19912         if (flags & NDR_IN) {
19913                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
19914                 ndr->depth++;
19915                 ndr->depth--;
19916         }
19917         if (flags & NDR_OUT) {
19918                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
19919                 ndr->depth++;
19920                 ndr_print_WERROR(ndr, "result", r->out.result);
19921                 ndr->depth--;
19922         }
19923         ndr->depth--;
19924 }
19925
19926 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19927 {
19928         if (flags & NDR_IN) {
19929         }
19930         if (flags & NDR_OUT) {
19931                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19932         }
19933         return NDR_ERR_SUCCESS;
19934 }
19935
19936 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
19937 {
19938         if (flags & NDR_IN) {
19939         }
19940         if (flags & NDR_OUT) {
19941                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19942         }
19943         return NDR_ERR_SUCCESS;
19944 }
19945
19946 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19947 {
19948         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
19949         ndr->depth++;
19950         if (flags & NDR_SET_VALUES) {
19951                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19952         }
19953         if (flags & NDR_IN) {
19954                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
19955                 ndr->depth++;
19956                 ndr->depth--;
19957         }
19958         if (flags & NDR_OUT) {
19959                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
19960                 ndr->depth++;
19961                 ndr_print_WERROR(ndr, "result", r->out.result);
19962                 ndr->depth--;
19963         }
19964         ndr->depth--;
19965 }
19966
19967 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
19968 {
19969         if (flags & NDR_IN) {
19970                 if (r->in.handle == NULL) {
19971                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19972                 }
19973                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
19975                 if (r->in.data_type) {
19976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19979                         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));
19980                 }
19981                 if (r->in.devmode_ctr == NULL) {
19982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19983                 }
19984                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19985         }
19986         if (flags & NDR_OUT) {
19987                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19988         }
19989         return NDR_ERR_SUCCESS;
19990 }
19991
19992 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
19993 {
19994         uint32_t _ptr_data_type;
19995         TALLOC_CTX *_mem_save_handle_0;
19996         TALLOC_CTX *_mem_save_data_type_0;
19997         TALLOC_CTX *_mem_save_devmode_ctr_0;
19998         if (flags & NDR_IN) {
19999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20000                         NDR_PULL_ALLOC(ndr, r->in.handle);
20001                 }
20002                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20004                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
20007                 if (_ptr_data_type) {
20008                         NDR_PULL_ALLOC(ndr, r->in.data_type);
20009                 } else {
20010                         r->in.data_type = NULL;
20011                 }
20012                 if (r->in.data_type) {
20013                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
20014                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
20015                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
20016                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
20017                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
20018                                 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));
20019                         }
20020                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
20021                         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));
20022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
20023                 }
20024                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20025                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20026                 }
20027                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20028                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20029                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20030                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20031         }
20032         if (flags & NDR_OUT) {
20033                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20034         }
20035         return NDR_ERR_SUCCESS;
20036 }
20037
20038 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
20039 {
20040         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
20041         ndr->depth++;
20042         if (flags & NDR_SET_VALUES) {
20043                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20044         }
20045         if (flags & NDR_IN) {
20046                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
20047                 ndr->depth++;
20048                 ndr_print_ptr(ndr, "handle", r->in.handle);
20049                 ndr->depth++;
20050                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20051                 ndr->depth--;
20052                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
20053                 ndr->depth++;
20054                 if (r->in.data_type) {
20055                         ndr_print_string(ndr, "data_type", r->in.data_type);
20056                 }
20057                 ndr->depth--;
20058                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20059                 ndr->depth++;
20060                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20061                 ndr->depth--;
20062                 ndr->depth--;
20063         }
20064         if (flags & NDR_OUT) {
20065                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
20066                 ndr->depth++;
20067                 ndr_print_WERROR(ndr, "result", r->out.result);
20068                 ndr->depth--;
20069         }
20070         ndr->depth--;
20071 }
20072
20073 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
20074 {
20075         if (flags & NDR_IN) {
20076                 if (r->in.handle == NULL) {
20077                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20078                 }
20079                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
20081                 if (r->in.architecture) {
20082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20085                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20086                 }
20087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20088                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20089                 if (r->in.buffer) {
20090                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20091                 }
20092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
20094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
20095         }
20096         if (flags & NDR_OUT) {
20097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20098                 if (r->out.info) {
20099                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20100                 }
20101                 if (r->out.needed == NULL) {
20102                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20103                 }
20104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20105                 if (r->out.server_major_version == NULL) {
20106                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20107                 }
20108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
20109                 if (r->out.server_minor_version == NULL) {
20110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20111                 }
20112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
20113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20114         }
20115         return NDR_ERR_SUCCESS;
20116 }
20117
20118 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
20119 {
20120         uint32_t _ptr_architecture;
20121         uint32_t _ptr_buffer;
20122         uint32_t _ptr_info;
20123         TALLOC_CTX *_mem_save_handle_0;
20124         TALLOC_CTX *_mem_save_architecture_0;
20125         TALLOC_CTX *_mem_save_buffer_0;
20126         TALLOC_CTX *_mem_save_info_0;
20127         TALLOC_CTX *_mem_save_needed_0;
20128         TALLOC_CTX *_mem_save_server_major_version_0;
20129         TALLOC_CTX *_mem_save_server_minor_version_0;
20130         if (flags & NDR_IN) {
20131                 ZERO_STRUCT(r->out);
20132
20133                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20134                         NDR_PULL_ALLOC(ndr, r->in.handle);
20135                 }
20136                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20137                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20138                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20139                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
20141                 if (_ptr_architecture) {
20142                         NDR_PULL_ALLOC(ndr, r->in.architecture);
20143                 } else {
20144                         r->in.architecture = NULL;
20145                 }
20146                 if (r->in.architecture) {
20147                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
20148                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
20149                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20150                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20151                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20152                                 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));
20153                         }
20154                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20155                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
20157                 }
20158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20160                 if (_ptr_buffer) {
20161                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20162                 } else {
20163                         r->in.buffer = NULL;
20164                 }
20165                 if (r->in.buffer) {
20166                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20167                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20168                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20170                 }
20171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
20173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
20174                 NDR_PULL_ALLOC(ndr, r->out.needed);
20175                 ZERO_STRUCTP(r->out.needed);
20176                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
20177                 ZERO_STRUCTP(r->out.server_major_version);
20178                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
20179                 ZERO_STRUCTP(r->out.server_minor_version);
20180         }
20181         if (flags & NDR_OUT) {
20182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20183                 if (_ptr_info) {
20184                         NDR_PULL_ALLOC(ndr, r->out.info);
20185                 } else {
20186                         r->out.info = NULL;
20187                 }
20188                 if (r->out.info) {
20189                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20190                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20191                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20193                 }
20194                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20195                         NDR_PULL_ALLOC(ndr, r->out.needed);
20196                 }
20197                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20198                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20200                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20202                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
20203                 }
20204                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
20205                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
20206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
20207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
20208                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20209                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
20210                 }
20211                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
20212                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
20213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
20214                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
20215                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20216         }
20217         return NDR_ERR_SUCCESS;
20218 }
20219
20220 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
20221 {
20222         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
20223         ndr->depth++;
20224         if (flags & NDR_SET_VALUES) {
20225                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20226         }
20227         if (flags & NDR_IN) {
20228                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
20229                 ndr->depth++;
20230                 ndr_print_ptr(ndr, "handle", r->in.handle);
20231                 ndr->depth++;
20232                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20233                 ndr->depth--;
20234                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
20235                 ndr->depth++;
20236                 if (r->in.architecture) {
20237                         ndr_print_string(ndr, "architecture", r->in.architecture);
20238                 }
20239                 ndr->depth--;
20240                 ndr_print_uint32(ndr, "level", r->in.level);
20241                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20242                 ndr->depth++;
20243                 if (r->in.buffer) {
20244                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20245                 }
20246                 ndr->depth--;
20247                 ndr_print_uint32(ndr, "offered", r->in.offered);
20248                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
20249                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
20250                 ndr->depth--;
20251         }
20252         if (flags & NDR_OUT) {
20253                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
20254                 ndr->depth++;
20255                 ndr_print_ptr(ndr, "info", r->out.info);
20256                 ndr->depth++;
20257                 if (r->out.info) {
20258                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
20259                 }
20260                 ndr->depth--;
20261                 ndr_print_ptr(ndr, "needed", r->out.needed);
20262                 ndr->depth++;
20263                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20264                 ndr->depth--;
20265                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
20266                 ndr->depth++;
20267                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
20268                 ndr->depth--;
20269                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
20270                 ndr->depth++;
20271                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
20272                 ndr->depth--;
20273                 ndr_print_WERROR(ndr, "result", r->out.result);
20274                 ndr->depth--;
20275         }
20276         ndr->depth--;
20277 }
20278
20279 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20280 {
20281         if (flags & NDR_IN) {
20282         }
20283         if (flags & NDR_OUT) {
20284                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20285         }
20286         return NDR_ERR_SUCCESS;
20287 }
20288
20289 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
20290 {
20291         if (flags & NDR_IN) {
20292         }
20293         if (flags & NDR_OUT) {
20294                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20295         }
20296         return NDR_ERR_SUCCESS;
20297 }
20298
20299 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
20300 {
20301         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
20302         ndr->depth++;
20303         if (flags & NDR_SET_VALUES) {
20304                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20305         }
20306         if (flags & NDR_IN) {
20307                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
20308                 ndr->depth++;
20309                 ndr->depth--;
20310         }
20311         if (flags & NDR_OUT) {
20312                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
20313                 ndr->depth++;
20314                 ndr_print_WERROR(ndr, "result", r->out.result);
20315                 ndr->depth--;
20316         }
20317         ndr->depth--;
20318 }
20319
20320 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20321 {
20322         if (flags & NDR_IN) {
20323         }
20324         if (flags & NDR_OUT) {
20325                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20326         }
20327         return NDR_ERR_SUCCESS;
20328 }
20329
20330 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
20331 {
20332         if (flags & NDR_IN) {
20333         }
20334         if (flags & NDR_OUT) {
20335                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20336         }
20337         return NDR_ERR_SUCCESS;
20338 }
20339
20340 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
20341 {
20342         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
20343         ndr->depth++;
20344         if (flags & NDR_SET_VALUES) {
20345                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20346         }
20347         if (flags & NDR_IN) {
20348                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
20349                 ndr->depth++;
20350                 ndr->depth--;
20351         }
20352         if (flags & NDR_OUT) {
20353                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
20354                 ndr->depth++;
20355                 ndr_print_WERROR(ndr, "result", r->out.result);
20356                 ndr->depth--;
20357         }
20358         ndr->depth--;
20359 }
20360
20361 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
20362 {
20363         if (flags & NDR_IN) {
20364                 if (r->in.handle == NULL) {
20365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20366                 }
20367                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20368         }
20369         if (flags & NDR_OUT) {
20370                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20371         }
20372         return NDR_ERR_SUCCESS;
20373 }
20374
20375 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
20376 {
20377         TALLOC_CTX *_mem_save_handle_0;
20378         if (flags & NDR_IN) {
20379                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20380                         NDR_PULL_ALLOC(ndr, r->in.handle);
20381                 }
20382                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20383                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20384                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20385                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20386         }
20387         if (flags & NDR_OUT) {
20388                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20389         }
20390         return NDR_ERR_SUCCESS;
20391 }
20392
20393 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
20394 {
20395         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
20396         ndr->depth++;
20397         if (flags & NDR_SET_VALUES) {
20398                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20399         }
20400         if (flags & NDR_IN) {
20401                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
20402                 ndr->depth++;
20403                 ndr_print_ptr(ndr, "handle", r->in.handle);
20404                 ndr->depth++;
20405                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20406                 ndr->depth--;
20407                 ndr->depth--;
20408         }
20409         if (flags & NDR_OUT) {
20410                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
20411                 ndr->depth++;
20412                 ndr_print_WERROR(ndr, "result", r->out.result);
20413                 ndr->depth--;
20414         }
20415         ndr->depth--;
20416 }
20417
20418 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20419 {
20420         if (flags & NDR_IN) {
20421         }
20422         if (flags & NDR_OUT) {
20423                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20424         }
20425         return NDR_ERR_SUCCESS;
20426 }
20427
20428 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20429 {
20430         if (flags & NDR_IN) {
20431         }
20432         if (flags & NDR_OUT) {
20433                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20434         }
20435         return NDR_ERR_SUCCESS;
20436 }
20437
20438 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
20439 {
20440         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20441         ndr->depth++;
20442         if (flags & NDR_SET_VALUES) {
20443                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20444         }
20445         if (flags & NDR_IN) {
20446                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20447                 ndr->depth++;
20448                 ndr->depth--;
20449         }
20450         if (flags & NDR_OUT) {
20451                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
20452                 ndr->depth++;
20453                 ndr_print_WERROR(ndr, "result", r->out.result);
20454                 ndr->depth--;
20455         }
20456         ndr->depth--;
20457 }
20458
20459 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
20460 {
20461         if (flags & NDR_IN) {
20462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
20465                 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));
20466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20467                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
20468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20469                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20470                 if (r->in.buffer) {
20471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20472                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20473                 }
20474         }
20475         if (flags & NDR_OUT) {
20476                 if (r->out.handle == NULL) {
20477                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20478                 }
20479                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20481         }
20482         return NDR_ERR_SUCCESS;
20483 }
20484
20485 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
20486 {
20487         uint32_t _ptr_buffer;
20488         TALLOC_CTX *_mem_save_buffer_0;
20489         TALLOC_CTX *_mem_save_handle_0;
20490         if (flags & NDR_IN) {
20491                 ZERO_STRUCT(r->out);
20492
20493                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
20494                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
20495                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
20496                         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));
20497                 }
20498                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
20499                 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));
20500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20501                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
20502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20503                 if (r->in.bufsize > 512) {
20504                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20505                 }
20506                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20507                 if (_ptr_buffer) {
20508                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20509                 } else {
20510                         r->in.buffer = NULL;
20511                 }
20512                 if (r->in.buffer) {
20513                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20514                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20516                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20517                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20519                 }
20520                 NDR_PULL_ALLOC(ndr, r->out.handle);
20521                 ZERO_STRUCTP(r->out.handle);
20522                 if (r->in.buffer) {
20523                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20524                 }
20525         }
20526         if (flags & NDR_OUT) {
20527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20528                         NDR_PULL_ALLOC(ndr, r->out.handle);
20529                 }
20530                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20531                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20532                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20534                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20535         }
20536         return NDR_ERR_SUCCESS;
20537 }
20538
20539 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
20540 {
20541         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
20542         ndr->depth++;
20543         if (flags & NDR_SET_VALUES) {
20544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20545         }
20546         if (flags & NDR_IN) {
20547                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
20548                 ndr->depth++;
20549                 ndr_print_string(ndr, "server_name", r->in.server_name);
20550                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20551                 ndr_print_winreg_Type(ndr, "type", r->in.type);
20552                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20553                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20554                 ndr->depth++;
20555                 if (r->in.buffer) {
20556                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20557                 }
20558                 ndr->depth--;
20559                 ndr->depth--;
20560         }
20561         if (flags & NDR_OUT) {
20562                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
20563                 ndr->depth++;
20564                 ndr_print_ptr(ndr, "handle", r->out.handle);
20565                 ndr->depth++;
20566                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20567                 ndr->depth--;
20568                 ndr_print_WERROR(ndr, "result", r->out.result);
20569                 ndr->depth--;
20570         }
20571         ndr->depth--;
20572 }
20573
20574 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
20575 {
20576         if (flags & NDR_IN) {
20577                 if (r->in.handle == NULL) {
20578                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20579                 }
20580                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20581                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20583                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20584                 if (r->in.buffer) {
20585                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20586                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20587                 }
20588         }
20589         if (flags & NDR_OUT) {
20590                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20591         }
20592         return NDR_ERR_SUCCESS;
20593 }
20594
20595 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
20596 {
20597         uint32_t _ptr_buffer;
20598         TALLOC_CTX *_mem_save_handle_0;
20599         TALLOC_CTX *_mem_save_buffer_0;
20600         if (flags & NDR_IN) {
20601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20602                         NDR_PULL_ALLOC(ndr, r->in.handle);
20603                 }
20604                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20605                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20606                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20608                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20610                 if (r->in.bufsize > 512) {
20611                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20612                 }
20613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20614                 if (_ptr_buffer) {
20615                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20616                 } else {
20617                         r->in.buffer = NULL;
20618                 }
20619                 if (r->in.buffer) {
20620                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20621                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20622                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20623                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20624                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20626                 }
20627                 if (r->in.buffer) {
20628                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20629                 }
20630         }
20631         if (flags & NDR_OUT) {
20632                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20633         }
20634         return NDR_ERR_SUCCESS;
20635 }
20636
20637 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
20638 {
20639         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
20640         ndr->depth++;
20641         if (flags & NDR_SET_VALUES) {
20642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20643         }
20644         if (flags & NDR_IN) {
20645                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
20646                 ndr->depth++;
20647                 ndr_print_ptr(ndr, "handle", r->in.handle);
20648                 ndr->depth++;
20649                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20650                 ndr->depth--;
20651                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20652                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20653                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20654                 ndr->depth++;
20655                 if (r->in.buffer) {
20656                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20657                 }
20658                 ndr->depth--;
20659                 ndr->depth--;
20660         }
20661         if (flags & NDR_OUT) {
20662                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
20663                 ndr->depth++;
20664                 ndr_print_WERROR(ndr, "result", r->out.result);
20665                 ndr->depth--;
20666         }
20667         ndr->depth--;
20668 }
20669
20670 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
20671 {
20672         if (flags & NDR_IN) {
20673                 if (r->in.handle == NULL) {
20674                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20675                 }
20676                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20677         }
20678         if (flags & NDR_OUT) {
20679                 if (r->out.handle == NULL) {
20680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20681                 }
20682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20683                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20684         }
20685         return NDR_ERR_SUCCESS;
20686 }
20687
20688 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
20689 {
20690         TALLOC_CTX *_mem_save_handle_0;
20691         if (flags & NDR_IN) {
20692                 ZERO_STRUCT(r->out);
20693
20694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20695                         NDR_PULL_ALLOC(ndr, r->in.handle);
20696                 }
20697                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20698                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20699                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20701                 NDR_PULL_ALLOC(ndr, r->out.handle);
20702                 *r->out.handle = *r->in.handle;
20703         }
20704         if (flags & NDR_OUT) {
20705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20706                         NDR_PULL_ALLOC(ndr, r->out.handle);
20707                 }
20708                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20709                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20710                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20712                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20713         }
20714         return NDR_ERR_SUCCESS;
20715 }
20716
20717 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
20718 {
20719         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
20720         ndr->depth++;
20721         if (flags & NDR_SET_VALUES) {
20722                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20723         }
20724         if (flags & NDR_IN) {
20725                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
20726                 ndr->depth++;
20727                 ndr_print_ptr(ndr, "handle", r->in.handle);
20728                 ndr->depth++;
20729                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20730                 ndr->depth--;
20731                 ndr->depth--;
20732         }
20733         if (flags & NDR_OUT) {
20734                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
20735                 ndr->depth++;
20736                 ndr_print_ptr(ndr, "handle", r->out.handle);
20737                 ndr->depth++;
20738                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20739                 ndr->depth--;
20740                 ndr_print_WERROR(ndr, "result", r->out.result);
20741                 ndr->depth--;
20742         }
20743         ndr->depth--;
20744 }
20745
20746 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
20747 {
20748         if (flags & NDR_IN) {
20749         }
20750         if (flags & NDR_OUT) {
20751                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20752         }
20753         return NDR_ERR_SUCCESS;
20754 }
20755
20756 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
20757 {
20758         if (flags & NDR_IN) {
20759         }
20760         if (flags & NDR_OUT) {
20761                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20762         }
20763         return NDR_ERR_SUCCESS;
20764 }
20765
20766 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
20767 {
20768         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
20769         ndr->depth++;
20770         if (flags & NDR_SET_VALUES) {
20771                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20772         }
20773         if (flags & NDR_IN) {
20774                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
20775                 ndr->depth++;
20776                 ndr->depth--;
20777         }
20778         if (flags & NDR_OUT) {
20779                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
20780                 ndr->depth++;
20781                 ndr_print_WERROR(ndr, "result", r->out.result);
20782                 ndr->depth--;
20783         }
20784         ndr->depth--;
20785 }
20786
20787 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20788 {
20789         if (flags & NDR_IN) {
20790         }
20791         if (flags & NDR_OUT) {
20792                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20793         }
20794         return NDR_ERR_SUCCESS;
20795 }
20796
20797 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20798 {
20799         if (flags & NDR_IN) {
20800         }
20801         if (flags & NDR_OUT) {
20802                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20803         }
20804         return NDR_ERR_SUCCESS;
20805 }
20806
20807 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20808 {
20809         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
20810         ndr->depth++;
20811         if (flags & NDR_SET_VALUES) {
20812                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20813         }
20814         if (flags & NDR_IN) {
20815                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
20816                 ndr->depth++;
20817                 ndr->depth--;
20818         }
20819         if (flags & NDR_OUT) {
20820                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
20821                 ndr->depth++;
20822                 ndr_print_WERROR(ndr, "result", r->out.result);
20823                 ndr->depth--;
20824         }
20825         ndr->depth--;
20826 }
20827
20828 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
20829 {
20830         if (flags & NDR_IN) {
20831         }
20832         if (flags & NDR_OUT) {
20833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20834         }
20835         return NDR_ERR_SUCCESS;
20836 }
20837
20838 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
20839 {
20840         if (flags & NDR_IN) {
20841         }
20842         if (flags & NDR_OUT) {
20843                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20844         }
20845         return NDR_ERR_SUCCESS;
20846 }
20847
20848 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
20849 {
20850         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
20851         ndr->depth++;
20852         if (flags & NDR_SET_VALUES) {
20853                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20854         }
20855         if (flags & NDR_IN) {
20856                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
20857                 ndr->depth++;
20858                 ndr->depth--;
20859         }
20860         if (flags & NDR_OUT) {
20861                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
20862                 ndr->depth++;
20863                 ndr_print_WERROR(ndr, "result", r->out.result);
20864                 ndr->depth--;
20865         }
20866         ndr->depth--;
20867 }
20868
20869 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
20870 {
20871         if (flags & NDR_IN) {
20872         }
20873         if (flags & NDR_OUT) {
20874                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20875         }
20876         return NDR_ERR_SUCCESS;
20877 }
20878
20879 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
20880 {
20881         if (flags & NDR_IN) {
20882         }
20883         if (flags & NDR_OUT) {
20884                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20885         }
20886         return NDR_ERR_SUCCESS;
20887 }
20888
20889 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
20890 {
20891         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
20892         ndr->depth++;
20893         if (flags & NDR_SET_VALUES) {
20894                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20895         }
20896         if (flags & NDR_IN) {
20897                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
20898                 ndr->depth++;
20899                 ndr->depth--;
20900         }
20901         if (flags & NDR_OUT) {
20902                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
20903                 ndr->depth++;
20904                 ndr_print_WERROR(ndr, "result", r->out.result);
20905                 ndr->depth--;
20906         }
20907         ndr->depth--;
20908 }
20909
20910 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20911 {
20912         if (flags & NDR_IN) {
20913                 if (r->in.handle == NULL) {
20914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20915                 }
20916                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20917                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
20919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
20920                 if (r->in.local_machine) {
20921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20924                         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));
20925                 }
20926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20927                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
20928                 if (r->in.notify_options) {
20929                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20930                 }
20931         }
20932         if (flags & NDR_OUT) {
20933                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20934         }
20935         return NDR_ERR_SUCCESS;
20936 }
20937
20938 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20939 {
20940         uint32_t _ptr_local_machine;
20941         uint32_t _ptr_notify_options;
20942         TALLOC_CTX *_mem_save_handle_0;
20943         TALLOC_CTX *_mem_save_local_machine_0;
20944         TALLOC_CTX *_mem_save_notify_options_0;
20945         if (flags & NDR_IN) {
20946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20947                         NDR_PULL_ALLOC(ndr, r->in.handle);
20948                 }
20949                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20950                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20951                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20953                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
20955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
20956                 if (_ptr_local_machine) {
20957                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
20958                 } else {
20959                         r->in.local_machine = NULL;
20960                 }
20961                 if (r->in.local_machine) {
20962                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
20963                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
20964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
20965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
20966                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
20967                                 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));
20968                         }
20969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
20970                         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));
20971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
20972                 }
20973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
20975                 if (_ptr_notify_options) {
20976                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
20977                 } else {
20978                         r->in.notify_options = NULL;
20979                 }
20980                 if (r->in.notify_options) {
20981                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20982                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
20983                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
20985                 }
20986         }
20987         if (flags & NDR_OUT) {
20988                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20989         }
20990         return NDR_ERR_SUCCESS;
20991 }
20992
20993 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20994 {
20995         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20996         ndr->depth++;
20997         if (flags & NDR_SET_VALUES) {
20998                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20999         }
21000         if (flags & NDR_IN) {
21001                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
21002                 ndr->depth++;
21003                 ndr_print_ptr(ndr, "handle", r->in.handle);
21004                 ndr->depth++;
21005                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21006                 ndr->depth--;
21007                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
21008                 ndr_print_uint32(ndr, "options", r->in.options);
21009                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
21010                 ndr->depth++;
21011                 if (r->in.local_machine) {
21012                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
21013                 }
21014                 ndr->depth--;
21015                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
21016                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
21017                 ndr->depth++;
21018                 if (r->in.notify_options) {
21019                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
21020                 }
21021                 ndr->depth--;
21022                 ndr->depth--;
21023         }
21024         if (flags & NDR_OUT) {
21025                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
21026                 ndr->depth++;
21027                 ndr_print_WERROR(ndr, "result", r->out.result);
21028                 ndr->depth--;
21029         }
21030         ndr->depth--;
21031 }
21032
21033 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
21034 {
21035         if (flags & NDR_IN) {
21036                 if (r->in.handle == NULL) {
21037                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21038                 }
21039                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
21041                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
21042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
21043                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
21044                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21045         }
21046         if (flags & NDR_OUT) {
21047                 if (r->out.reply_result == NULL) {
21048                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21049                 }
21050                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
21051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21052         }
21053         return NDR_ERR_SUCCESS;
21054 }
21055
21056 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
21057 {
21058         TALLOC_CTX *_mem_save_handle_0;
21059         TALLOC_CTX *_mem_save_reply_result_0;
21060         if (flags & NDR_IN) {
21061                 ZERO_STRUCT(r->out);
21062
21063                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21064                         NDR_PULL_ALLOC(ndr, r->in.handle);
21065                 }
21066                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21067                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21068                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
21071                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
21072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
21073                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
21074                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21075                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
21076                 ZERO_STRUCTP(r->out.reply_result);
21077         }
21078         if (flags & NDR_OUT) {
21079                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21080                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
21081                 }
21082                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
21083                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
21084                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
21085                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
21086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21087         }
21088         return NDR_ERR_SUCCESS;
21089 }
21090
21091 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
21092 {
21093         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
21094         ndr->depth++;
21095         if (flags & NDR_SET_VALUES) {
21096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21097         }
21098         if (flags & NDR_IN) {
21099                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
21100                 ndr->depth++;
21101                 ndr_print_ptr(ndr, "handle", r->in.handle);
21102                 ndr->depth++;
21103                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21104                 ndr->depth--;
21105                 ndr_print_uint32(ndr, "color", r->in.color);
21106                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
21107                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
21108                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
21109                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
21110                 ndr->depth--;
21111         }
21112         if (flags & NDR_OUT) {
21113                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
21114                 ndr->depth++;
21115                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
21116                 ndr->depth++;
21117                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
21118                 ndr->depth--;
21119                 ndr_print_WERROR(ndr, "result", r->out.result);
21120                 ndr->depth--;
21121         }
21122         ndr->depth--;
21123 }
21124
21125 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
21126 {
21127         if (flags & NDR_IN) {
21128                 if (r->in.handle == NULL) {
21129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21130                 }
21131                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
21133                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
21134                 if (r->in.options) {
21135                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
21136                 }
21137         }
21138         if (flags & NDR_OUT) {
21139                 if (r->out.info == NULL) {
21140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21141                 }
21142                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
21143                 if (*r->out.info) {
21144                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
21145                 }
21146                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21147         }
21148         return NDR_ERR_SUCCESS;
21149 }
21150
21151 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
21152 {
21153         uint32_t _ptr_options;
21154         uint32_t _ptr_info;
21155         TALLOC_CTX *_mem_save_handle_0;
21156         TALLOC_CTX *_mem_save_options_0;
21157         TALLOC_CTX *_mem_save_info_0;
21158         TALLOC_CTX *_mem_save_info_1;
21159         if (flags & NDR_IN) {
21160                 ZERO_STRUCT(r->out);
21161
21162                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21163                         NDR_PULL_ALLOC(ndr, r->in.handle);
21164                 }
21165                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21166                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21167                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
21170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
21171                 if (_ptr_options) {
21172                         NDR_PULL_ALLOC(ndr, r->in.options);
21173                 } else {
21174                         r->in.options = NULL;
21175                 }
21176                 if (r->in.options) {
21177                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
21178                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
21179                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
21180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
21181                 }
21182                 NDR_PULL_ALLOC(ndr, r->out.info);
21183                 ZERO_STRUCTP(r->out.info);
21184         }
21185         if (flags & NDR_OUT) {
21186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21187                         NDR_PULL_ALLOC(ndr, r->out.info);
21188                 }
21189                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21190                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
21191                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21192                 if (_ptr_info) {
21193                         NDR_PULL_ALLOC(ndr, *r->out.info);
21194                 } else {
21195                         *r->out.info = NULL;
21196                 }
21197                 if (*r->out.info) {
21198                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
21199                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
21200                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
21201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
21202                 }
21203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
21204                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21205         }
21206         return NDR_ERR_SUCCESS;
21207 }
21208
21209 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
21210 {
21211         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
21212         ndr->depth++;
21213         if (flags & NDR_SET_VALUES) {
21214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21215         }
21216         if (flags & NDR_IN) {
21217                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
21218                 ndr->depth++;
21219                 ndr_print_ptr(ndr, "handle", r->in.handle);
21220                 ndr->depth++;
21221                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21222                 ndr->depth--;
21223                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
21224                 ndr_print_ptr(ndr, "options", r->in.options);
21225                 ndr->depth++;
21226                 if (r->in.options) {
21227                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
21228                 }
21229                 ndr->depth--;
21230                 ndr->depth--;
21231         }
21232         if (flags & NDR_OUT) {
21233                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
21234                 ndr->depth++;
21235                 ndr_print_ptr(ndr, "info", r->out.info);
21236                 ndr->depth++;
21237                 ndr_print_ptr(ndr, "info", *r->out.info);
21238                 ndr->depth++;
21239                 if (*r->out.info) {
21240                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
21241                 }
21242                 ndr->depth--;
21243                 ndr->depth--;
21244                 ndr_print_WERROR(ndr, "result", r->out.result);
21245                 ndr->depth--;
21246         }
21247         ndr->depth--;
21248 }
21249
21250 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
21251 {
21252         if (flags & NDR_IN) {
21253         }
21254         if (flags & NDR_OUT) {
21255                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21256         }
21257         return NDR_ERR_SUCCESS;
21258 }
21259
21260 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
21261 {
21262         if (flags & NDR_IN) {
21263         }
21264         if (flags & NDR_OUT) {
21265                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21266         }
21267         return NDR_ERR_SUCCESS;
21268 }
21269
21270 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
21271 {
21272         ndr_print_struct(ndr, name, "spoolss_44");
21273         ndr->depth++;
21274         if (flags & NDR_SET_VALUES) {
21275                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21276         }
21277         if (flags & NDR_IN) {
21278                 ndr_print_struct(ndr, "in", "spoolss_44");
21279                 ndr->depth++;
21280                 ndr->depth--;
21281         }
21282         if (flags & NDR_OUT) {
21283                 ndr_print_struct(ndr, "out", "spoolss_44");
21284                 ndr->depth++;
21285                 ndr_print_WERROR(ndr, "result", r->out.result);
21286                 ndr->depth--;
21287         }
21288         ndr->depth--;
21289 }
21290
21291 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
21292 {
21293         if (flags & NDR_IN) {
21294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
21295                 if (r->in.printername) {
21296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21300                 }
21301                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
21302                 if (r->in.datatype) {
21303                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21307                 }
21308                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21309                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
21310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21311                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21312                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21313         }
21314         if (flags & NDR_OUT) {
21315                 if (r->out.handle == NULL) {
21316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21317                 }
21318                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21320         }
21321         return NDR_ERR_SUCCESS;
21322 }
21323
21324 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
21325 {
21326         uint32_t _ptr_printername;
21327         uint32_t _ptr_datatype;
21328         TALLOC_CTX *_mem_save_printername_0;
21329         TALLOC_CTX *_mem_save_datatype_0;
21330         TALLOC_CTX *_mem_save_handle_0;
21331         if (flags & NDR_IN) {
21332                 ZERO_STRUCT(r->out);
21333
21334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
21335                 if (_ptr_printername) {
21336                         NDR_PULL_ALLOC(ndr, r->in.printername);
21337                 } else {
21338                         r->in.printername = NULL;
21339                 }
21340                 if (r->in.printername) {
21341                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21342                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
21343                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
21344                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
21345                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
21346                                 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));
21347                         }
21348                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
21349                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
21350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
21351                 }
21352                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
21353                 if (_ptr_datatype) {
21354                         NDR_PULL_ALLOC(ndr, r->in.datatype);
21355                 } else {
21356                         r->in.datatype = NULL;
21357                 }
21358                 if (r->in.datatype) {
21359                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
21360                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
21361                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
21362                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
21363                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
21364                                 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));
21365                         }
21366                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
21367                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
21368                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
21369                 }
21370                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21371                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
21372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21373                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
21374                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
21375                 NDR_PULL_ALLOC(ndr, r->out.handle);
21376                 ZERO_STRUCTP(r->out.handle);
21377         }
21378         if (flags & NDR_OUT) {
21379                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21380                         NDR_PULL_ALLOC(ndr, r->out.handle);
21381                 }
21382                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21383                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21384                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21385                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21386                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21387         }
21388         return NDR_ERR_SUCCESS;
21389 }
21390
21391 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
21392 {
21393         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
21394         ndr->depth++;
21395         if (flags & NDR_SET_VALUES) {
21396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21397         }
21398         if (flags & NDR_IN) {
21399                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
21400                 ndr->depth++;
21401                 ndr_print_ptr(ndr, "printername", r->in.printername);
21402                 ndr->depth++;
21403                 if (r->in.printername) {
21404                         ndr_print_string(ndr, "printername", r->in.printername);
21405                 }
21406                 ndr->depth--;
21407                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
21408                 ndr->depth++;
21409                 if (r->in.datatype) {
21410                         ndr_print_string(ndr, "datatype", r->in.datatype);
21411                 }
21412                 ndr->depth--;
21413                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
21414                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
21415                 ndr_print_uint32(ndr, "level", r->in.level);
21416                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
21417                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
21418                 ndr->depth--;
21419         }
21420         if (flags & NDR_OUT) {
21421                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
21422                 ndr->depth++;
21423                 ndr_print_ptr(ndr, "handle", r->out.handle);
21424                 ndr->depth++;
21425                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21426                 ndr->depth--;
21427                 ndr_print_WERROR(ndr, "result", r->out.result);
21428                 ndr->depth--;
21429         }
21430         ndr->depth--;
21431 }
21432
21433 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
21434 {
21435         if (flags & NDR_IN) {
21436                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21437                 if (r->in.server) {
21438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21441                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21442                 }
21443                 if (r->in.info_ctr == NULL) {
21444                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21445                 }
21446                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21447                 if (r->in.devmode_ctr == NULL) {
21448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21449                 }
21450                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21451                 if (r->in.secdesc_ctr == NULL) {
21452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21453                 }
21454                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21455                 if (r->in.userlevel_ctr == NULL) {
21456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21457                 }
21458                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21459         }
21460         if (flags & NDR_OUT) {
21461                 if (r->out.handle == NULL) {
21462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21463                 }
21464                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21465                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21466         }
21467         return NDR_ERR_SUCCESS;
21468 }
21469
21470 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
21471 {
21472         uint32_t _ptr_server;
21473         TALLOC_CTX *_mem_save_server_0;
21474         TALLOC_CTX *_mem_save_info_ctr_0;
21475         TALLOC_CTX *_mem_save_devmode_ctr_0;
21476         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21477         TALLOC_CTX *_mem_save_userlevel_ctr_0;
21478         TALLOC_CTX *_mem_save_handle_0;
21479         if (flags & NDR_IN) {
21480                 ZERO_STRUCT(r->out);
21481
21482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21483                 if (_ptr_server) {
21484                         NDR_PULL_ALLOC(ndr, r->in.server);
21485                 } else {
21486                         r->in.server = NULL;
21487                 }
21488                 if (r->in.server) {
21489                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21490                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21491                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21492                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21493                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21494                                 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));
21495                         }
21496                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21497                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21499                 }
21500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21501                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21502                 }
21503                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21504                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21505                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21508                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21509                 }
21510                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21511                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21512                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21515                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21516                 }
21517                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21518                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21519                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21522                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
21523                 }
21524                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21525                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
21526                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
21527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21528                 NDR_PULL_ALLOC(ndr, r->out.handle);
21529                 ZERO_STRUCTP(r->out.handle);
21530         }
21531         if (flags & NDR_OUT) {
21532                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21533                         NDR_PULL_ALLOC(ndr, r->out.handle);
21534                 }
21535                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21536                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21537                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21538                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21539                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21540         }
21541         return NDR_ERR_SUCCESS;
21542 }
21543
21544 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
21545 {
21546         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
21547         ndr->depth++;
21548         if (flags & NDR_SET_VALUES) {
21549                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21550         }
21551         if (flags & NDR_IN) {
21552                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
21553                 ndr->depth++;
21554                 ndr_print_ptr(ndr, "server", r->in.server);
21555                 ndr->depth++;
21556                 if (r->in.server) {
21557                         ndr_print_string(ndr, "server", r->in.server);
21558                 }
21559                 ndr->depth--;
21560                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21561                 ndr->depth++;
21562                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21563                 ndr->depth--;
21564                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21565                 ndr->depth++;
21566                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21567                 ndr->depth--;
21568                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21569                 ndr->depth++;
21570                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21571                 ndr->depth--;
21572                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21573                 ndr->depth++;
21574                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21575                 ndr->depth--;
21576                 ndr->depth--;
21577         }
21578         if (flags & NDR_OUT) {
21579                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
21580                 ndr->depth++;
21581                 ndr_print_ptr(ndr, "handle", r->out.handle);
21582                 ndr->depth++;
21583                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21584                 ndr->depth--;
21585                 ndr_print_WERROR(ndr, "result", r->out.result);
21586                 ndr->depth--;
21587         }
21588         ndr->depth--;
21589 }
21590
21591 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
21592 {
21593         if (flags & NDR_IN) {
21594         }
21595         if (flags & NDR_OUT) {
21596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21597         }
21598         return NDR_ERR_SUCCESS;
21599 }
21600
21601 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
21602 {
21603         if (flags & NDR_IN) {
21604         }
21605         if (flags & NDR_OUT) {
21606                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21607         }
21608         return NDR_ERR_SUCCESS;
21609 }
21610
21611 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
21612 {
21613         ndr_print_struct(ndr, name, "spoolss_47");
21614         ndr->depth++;
21615         if (flags & NDR_SET_VALUES) {
21616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21617         }
21618         if (flags & NDR_IN) {
21619                 ndr_print_struct(ndr, "in", "spoolss_47");
21620                 ndr->depth++;
21621                 ndr->depth--;
21622         }
21623         if (flags & NDR_OUT) {
21624                 ndr_print_struct(ndr, "out", "spoolss_47");
21625                 ndr->depth++;
21626                 ndr_print_WERROR(ndr, "result", r->out.result);
21627                 ndr->depth--;
21628         }
21629         ndr->depth--;
21630 }
21631
21632 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
21633 {
21634         if (flags & NDR_IN) {
21635                 if (r->in.handle == NULL) {
21636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21637                 }
21638                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
21640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
21641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
21642         }
21643         if (flags & NDR_OUT) {
21644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
21645                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
21646                 if (r->out.value_needed == NULL) {
21647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21648                 }
21649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
21650                 if (r->out.printerdata_type == NULL) {
21651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21652                 }
21653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
21654                 if (r->out.buffer == NULL) {
21655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21656                 }
21657                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
21658                 if (r->out.data_needed == NULL) {
21659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21660                 }
21661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
21662                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21663         }
21664         return NDR_ERR_SUCCESS;
21665 }
21666
21667 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
21668 {
21669         TALLOC_CTX *_mem_save_handle_0;
21670         TALLOC_CTX *_mem_save_value_needed_0;
21671         TALLOC_CTX *_mem_save_printerdata_type_0;
21672         TALLOC_CTX *_mem_save_buffer_0;
21673         TALLOC_CTX *_mem_save_data_needed_0;
21674         if (flags & NDR_IN) {
21675                 ZERO_STRUCT(r->out);
21676
21677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21678                         NDR_PULL_ALLOC(ndr, r->in.handle);
21679                 }
21680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
21685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
21686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
21687                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
21688                 ZERO_STRUCTP(r->out.value_needed);
21689                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21690                 ZERO_STRUCTP(r->out.printerdata_type);
21691                 NDR_PULL_ALLOC(ndr, r->out.buffer);
21692                 ZERO_STRUCTP(r->out.buffer);
21693                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
21694                 ZERO_STRUCTP(r->out.data_needed);
21695         }
21696         if (flags & NDR_OUT) {
21697                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
21698                 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));
21699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21700                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
21701                 }
21702                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21703                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
21704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
21705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
21706                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21707                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21708                 }
21709                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21710                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
21711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
21712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
21713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21714                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21715                 }
21716                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21717                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
21718                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
21719                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
21720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21721                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
21722                 }
21723                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21724                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
21725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
21726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
21727                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21728                 if (r->out.value_name) {
21729                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
21730                 }
21731         }
21732         return NDR_ERR_SUCCESS;
21733 }
21734
21735 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
21736 {
21737         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
21738         ndr->depth++;
21739         if (flags & NDR_SET_VALUES) {
21740                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21741         }
21742         if (flags & NDR_IN) {
21743                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
21744                 ndr->depth++;
21745                 ndr_print_ptr(ndr, "handle", r->in.handle);
21746                 ndr->depth++;
21747                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21748                 ndr->depth--;
21749                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
21750                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
21751                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
21752                 ndr->depth--;
21753         }
21754         if (flags & NDR_OUT) {
21755                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
21756                 ndr->depth++;
21757                 ndr_print_string(ndr, "value_name", r->out.value_name);
21758                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
21759                 ndr->depth++;
21760                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
21761                 ndr->depth--;
21762                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
21763                 ndr->depth++;
21764                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
21765                 ndr->depth--;
21766                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21767                 ndr->depth++;
21768                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
21769                 ndr->depth--;
21770                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
21771                 ndr->depth++;
21772                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
21773                 ndr->depth--;
21774                 ndr_print_WERROR(ndr, "result", r->out.result);
21775                 ndr->depth--;
21776         }
21777         ndr->depth--;
21778 }
21779
21780 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
21781 {
21782         if (flags & NDR_IN) {
21783                 if (r->in.handle == NULL) {
21784                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21785                 }
21786                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21790                 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));
21791         }
21792         if (flags & NDR_OUT) {
21793                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21794         }
21795         return NDR_ERR_SUCCESS;
21796 }
21797
21798 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
21799 {
21800         TALLOC_CTX *_mem_save_handle_0;
21801         if (flags & NDR_IN) {
21802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21803                         NDR_PULL_ALLOC(ndr, r->in.handle);
21804                 }
21805                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21806                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21807                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21810                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21811                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21812                         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));
21813                 }
21814                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21815                 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));
21816         }
21817         if (flags & NDR_OUT) {
21818                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21819         }
21820         return NDR_ERR_SUCCESS;
21821 }
21822
21823 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
21824 {
21825         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
21826         ndr->depth++;
21827         if (flags & NDR_SET_VALUES) {
21828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21829         }
21830         if (flags & NDR_IN) {
21831                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
21832                 ndr->depth++;
21833                 ndr_print_ptr(ndr, "handle", r->in.handle);
21834                 ndr->depth++;
21835                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21836                 ndr->depth--;
21837                 ndr_print_string(ndr, "value_name", r->in.value_name);
21838                 ndr->depth--;
21839         }
21840         if (flags & NDR_OUT) {
21841                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
21842                 ndr->depth++;
21843                 ndr_print_WERROR(ndr, "result", r->out.result);
21844                 ndr->depth--;
21845         }
21846         ndr->depth--;
21847 }
21848
21849 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
21850 {
21851         if (flags & NDR_IN) {
21852         }
21853         if (flags & NDR_OUT) {
21854                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21855         }
21856         return NDR_ERR_SUCCESS;
21857 }
21858
21859 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
21860 {
21861         if (flags & NDR_IN) {
21862         }
21863         if (flags & NDR_OUT) {
21864                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21865         }
21866         return NDR_ERR_SUCCESS;
21867 }
21868
21869 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
21870 {
21871         ndr_print_struct(ndr, name, "spoolss_4a");
21872         ndr->depth++;
21873         if (flags & NDR_SET_VALUES) {
21874                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21875         }
21876         if (flags & NDR_IN) {
21877                 ndr_print_struct(ndr, "in", "spoolss_4a");
21878                 ndr->depth++;
21879                 ndr->depth--;
21880         }
21881         if (flags & NDR_OUT) {
21882                 ndr_print_struct(ndr, "out", "spoolss_4a");
21883                 ndr->depth++;
21884                 ndr_print_WERROR(ndr, "result", r->out.result);
21885                 ndr->depth--;
21886         }
21887         ndr->depth--;
21888 }
21889
21890 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
21891 {
21892         if (flags & NDR_IN) {
21893         }
21894         if (flags & NDR_OUT) {
21895                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21896         }
21897         return NDR_ERR_SUCCESS;
21898 }
21899
21900 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
21901 {
21902         if (flags & NDR_IN) {
21903         }
21904         if (flags & NDR_OUT) {
21905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21906         }
21907         return NDR_ERR_SUCCESS;
21908 }
21909
21910 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
21911 {
21912         ndr_print_struct(ndr, name, "spoolss_4b");
21913         ndr->depth++;
21914         if (flags & NDR_SET_VALUES) {
21915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21916         }
21917         if (flags & NDR_IN) {
21918                 ndr_print_struct(ndr, "in", "spoolss_4b");
21919                 ndr->depth++;
21920                 ndr->depth--;
21921         }
21922         if (flags & NDR_OUT) {
21923                 ndr_print_struct(ndr, "out", "spoolss_4b");
21924                 ndr->depth++;
21925                 ndr_print_WERROR(ndr, "result", r->out.result);
21926                 ndr->depth--;
21927         }
21928         ndr->depth--;
21929 }
21930
21931 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
21932 {
21933         if (flags & NDR_IN) {
21934         }
21935         if (flags & NDR_OUT) {
21936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21937         }
21938         return NDR_ERR_SUCCESS;
21939 }
21940
21941 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
21942 {
21943         if (flags & NDR_IN) {
21944         }
21945         if (flags & NDR_OUT) {
21946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21947         }
21948         return NDR_ERR_SUCCESS;
21949 }
21950
21951 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
21952 {
21953         ndr_print_struct(ndr, name, "spoolss_4c");
21954         ndr->depth++;
21955         if (flags & NDR_SET_VALUES) {
21956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21957         }
21958         if (flags & NDR_IN) {
21959                 ndr_print_struct(ndr, "in", "spoolss_4c");
21960                 ndr->depth++;
21961                 ndr->depth--;
21962         }
21963         if (flags & NDR_OUT) {
21964                 ndr_print_struct(ndr, "out", "spoolss_4c");
21965                 ndr->depth++;
21966                 ndr_print_WERROR(ndr, "result", r->out.result);
21967                 ndr->depth--;
21968         }
21969         ndr->depth--;
21970 }
21971
21972 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
21973 {
21974         if (flags & NDR_IN) {
21975                 if (r->in.handle == NULL) {
21976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21977                 }
21978                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21982                 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));
21983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21986                 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));
21987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
21988                 if (r->in.buffer == NULL) {
21989                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21990                 }
21991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21992                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21994         }
21995         if (flags & NDR_OUT) {
21996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21997         }
21998         return NDR_ERR_SUCCESS;
21999 }
22000
22001 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
22002 {
22003         TALLOC_CTX *_mem_save_handle_0;
22004         if (flags & NDR_IN) {
22005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22006                         NDR_PULL_ALLOC(ndr, r->in.handle);
22007                 }
22008                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22009                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22010                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22012                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22013                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22014                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22015                         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));
22016                 }
22017                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22018                 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));
22019                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22020                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22021                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22022                         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));
22023                 }
22024                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22025                 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));
22026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
22027                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22028                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22029                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22030                 }
22031                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22033                 if (r->in.buffer) {
22034                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
22035                 }
22036         }
22037         if (flags & NDR_OUT) {
22038                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22039         }
22040         return NDR_ERR_SUCCESS;
22041 }
22042
22043 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
22044 {
22045         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
22046         ndr->depth++;
22047         if (flags & NDR_SET_VALUES) {
22048                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22049         }
22050         if (flags & NDR_IN) {
22051                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
22052                 ndr->depth++;
22053                 ndr_print_ptr(ndr, "handle", r->in.handle);
22054                 ndr->depth++;
22055                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22056                 ndr->depth--;
22057                 ndr_print_string(ndr, "key_name", r->in.key_name);
22058                 ndr_print_string(ndr, "value_name", r->in.value_name);
22059                 ndr_print_uint32(ndr, "type", r->in.type);
22060                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22061                 ndr->depth++;
22062                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
22063                 ndr->depth--;
22064                 ndr_print_uint32(ndr, "offered", r->in.offered);
22065                 ndr->depth--;
22066         }
22067         if (flags & NDR_OUT) {
22068                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
22069                 ndr->depth++;
22070                 ndr_print_WERROR(ndr, "result", r->out.result);
22071                 ndr->depth--;
22072         }
22073         ndr->depth--;
22074 }
22075
22076 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
22077 {
22078         if (flags & NDR_IN) {
22079                 if (r->in.handle == NULL) {
22080                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22081                 }
22082                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22086                 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));
22087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22090                 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));
22091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22092         }
22093         if (flags & NDR_OUT) {
22094                 if (r->out.type == NULL) {
22095                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22096                 }
22097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
22098                 if (r->out.buffer == NULL) {
22099                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22100                 }
22101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22102                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22103                 if (r->out.needed == NULL) {
22104                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22105                 }
22106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22107                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22108         }
22109         return NDR_ERR_SUCCESS;
22110 }
22111
22112 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
22113 {
22114         TALLOC_CTX *_mem_save_handle_0;
22115         TALLOC_CTX *_mem_save_type_0;
22116         TALLOC_CTX *_mem_save_needed_0;
22117         if (flags & NDR_IN) {
22118                 ZERO_STRUCT(r->out);
22119
22120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22121                         NDR_PULL_ALLOC(ndr, r->in.handle);
22122                 }
22123                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22124                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22125                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22127                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22128                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22129                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22130                         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));
22131                 }
22132                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22133                 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));
22134                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22135                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22136                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22137                         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));
22138                 }
22139                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22140                 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));
22141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22142                 NDR_PULL_ALLOC(ndr, r->out.type);
22143                 ZERO_STRUCTP(r->out.type);
22144                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
22145                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
22146                 NDR_PULL_ALLOC(ndr, r->out.needed);
22147                 ZERO_STRUCTP(r->out.needed);
22148         }
22149         if (flags & NDR_OUT) {
22150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22151                         NDR_PULL_ALLOC(ndr, r->out.type);
22152                 }
22153                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
22154                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
22155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
22156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
22157                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22159                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22160                 }
22161                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22162                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22163                         NDR_PULL_ALLOC(ndr, r->out.needed);
22164                 }
22165                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22166                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22170                 if (r->out.buffer) {
22171                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22172                 }
22173         }
22174         return NDR_ERR_SUCCESS;
22175 }
22176
22177 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
22178 {
22179         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
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_GetPrinterDataEx");
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_string(ndr, "value_name", r->in.value_name);
22193                 ndr_print_uint32(ndr, "offered", r->in.offered);
22194                 ndr->depth--;
22195         }
22196         if (flags & NDR_OUT) {
22197                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
22198                 ndr->depth++;
22199                 ndr_print_ptr(ndr, "type", r->out.type);
22200                 ndr->depth++;
22201                 ndr_print_uint32(ndr, "type", *r->out.type);
22202                 ndr->depth--;
22203                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22204                 ndr->depth++;
22205                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22206                 ndr->depth--;
22207                 ndr_print_ptr(ndr, "needed", r->out.needed);
22208                 ndr->depth++;
22209                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22210                 ndr->depth--;
22211                 ndr_print_WERROR(ndr, "result", r->out.result);
22212                 ndr->depth--;
22213         }
22214         ndr->depth--;
22215 }
22216
22217 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
22218 {
22219         if (flags & NDR_IN) {
22220                 if (r->in.handle == NULL) {
22221                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22222                 }
22223                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22227                 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));
22228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22229         }
22230         if (flags & NDR_OUT) {
22231                 if (r->out.buffer == NULL) {
22232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22233                 }
22234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22235                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22236                 if (r->out.needed == NULL) {
22237                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22238                 }
22239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22240                 if (r->out.count == NULL) {
22241                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22242                 }
22243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22244                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22245         }
22246         return NDR_ERR_SUCCESS;
22247 }
22248
22249 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
22250 {
22251         TALLOC_CTX *_mem_save_handle_0;
22252         TALLOC_CTX *_mem_save_needed_0;
22253         TALLOC_CTX *_mem_save_count_0;
22254         if (flags & NDR_IN) {
22255                 ZERO_STRUCT(r->out);
22256
22257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22258                         NDR_PULL_ALLOC(ndr, r->in.handle);
22259                 }
22260                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22261                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22262                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22264                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22265                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22266                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22267                         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));
22268                 }
22269                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22270                 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));
22271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22272                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
22273                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
22274                 NDR_PULL_ALLOC(ndr, r->out.needed);
22275                 ZERO_STRUCTP(r->out.needed);
22276                 NDR_PULL_ALLOC(ndr, r->out.count);
22277                 ZERO_STRUCTP(r->out.count);
22278         }
22279         if (flags & NDR_OUT) {
22280                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22282                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22283                 }
22284                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22286                         NDR_PULL_ALLOC(ndr, r->out.needed);
22287                 }
22288                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22289                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22291                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22292                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22293                         NDR_PULL_ALLOC(ndr, r->out.count);
22294                 }
22295                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22296                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22298                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22299                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22300                 if (r->out.buffer) {
22301                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22302                 }
22303         }
22304         return NDR_ERR_SUCCESS;
22305 }
22306
22307 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
22308 {
22309         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
22310         ndr->depth++;
22311         if (flags & NDR_SET_VALUES) {
22312                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22313         }
22314         if (flags & NDR_IN) {
22315                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
22316                 ndr->depth++;
22317                 ndr_print_ptr(ndr, "handle", r->in.handle);
22318                 ndr->depth++;
22319                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22320                 ndr->depth--;
22321                 ndr_print_string(ndr, "key_name", r->in.key_name);
22322                 ndr_print_uint32(ndr, "offered", r->in.offered);
22323                 ndr->depth--;
22324         }
22325         if (flags & NDR_OUT) {
22326                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
22327                 ndr->depth++;
22328                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22329                 ndr->depth++;
22330                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22331                 ndr->depth--;
22332                 ndr_print_ptr(ndr, "needed", r->out.needed);
22333                 ndr->depth++;
22334                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22335                 ndr->depth--;
22336                 ndr_print_ptr(ndr, "count", r->out.count);
22337                 ndr->depth++;
22338                 ndr_print_uint32(ndr, "count", *r->out.count);
22339                 ndr->depth--;
22340                 ndr_print_WERROR(ndr, "result", r->out.result);
22341                 ndr->depth--;
22342         }
22343         ndr->depth--;
22344 }
22345
22346 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
22347 {
22348         uint32_t cntr_key_buffer_1;
22349         if (flags & NDR_IN) {
22350                 if (r->in.handle == NULL) {
22351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22352                 }
22353                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22357                 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));
22358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
22359         }
22360         if (flags & NDR_OUT) {
22361                 if (r->out.key_buffer == NULL) {
22362                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22363                 }
22364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
22365                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22366                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
22367                 }
22368                 if (r->out.needed == NULL) {
22369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22370                 }
22371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22372                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22373         }
22374         return NDR_ERR_SUCCESS;
22375 }
22376
22377 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
22378 {
22379         uint32_t cntr_key_buffer_1;
22380         TALLOC_CTX *_mem_save_handle_0;
22381         TALLOC_CTX *_mem_save_key_buffer_1;
22382         TALLOC_CTX *_mem_save_needed_0;
22383         if (flags & NDR_IN) {
22384                 ZERO_STRUCT(r->out);
22385
22386                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22387                         NDR_PULL_ALLOC(ndr, r->in.handle);
22388                 }
22389                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22390                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22391                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22393                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22394                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22395                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22396                         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));
22397                 }
22398                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22399                 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));
22400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
22401                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
22402                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
22403                 NDR_PULL_ALLOC(ndr, r->out.needed);
22404                 ZERO_STRUCTP(r->out.needed);
22405         }
22406         if (flags & NDR_OUT) {
22407                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
22408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22409                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
22410                 }
22411                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
22412                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
22413                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
22414                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
22415                 }
22416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
22417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22418                         NDR_PULL_ALLOC(ndr, r->out.needed);
22419                 }
22420                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22421                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22425                 if (r->out.key_buffer) {
22426                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
22427                 }
22428         }
22429         return NDR_ERR_SUCCESS;
22430 }
22431
22432 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
22433 {
22434         uint32_t cntr_key_buffer_1;
22435         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
22436         ndr->depth++;
22437         if (flags & NDR_SET_VALUES) {
22438                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22439         }
22440         if (flags & NDR_IN) {
22441                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
22442                 ndr->depth++;
22443                 ndr_print_ptr(ndr, "handle", r->in.handle);
22444                 ndr->depth++;
22445                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22446                 ndr->depth--;
22447                 ndr_print_string(ndr, "key_name", r->in.key_name);
22448                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
22449                 ndr->depth--;
22450         }
22451         if (flags & NDR_OUT) {
22452                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
22453                 ndr->depth++;
22454                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
22455                 ndr->depth++;
22456                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
22457                 ndr->depth++;
22458                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
22459                         char *idx_1=NULL;
22460                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
22461                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
22462                                 free(idx_1);
22463                         }
22464                 }
22465                 ndr->depth--;
22466                 ndr->depth--;
22467                 ndr_print_ptr(ndr, "needed", r->out.needed);
22468                 ndr->depth++;
22469                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22470                 ndr->depth--;
22471                 ndr_print_WERROR(ndr, "result", r->out.result);
22472                 ndr->depth--;
22473         }
22474         ndr->depth--;
22475 }
22476
22477 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
22478 {
22479         if (flags & NDR_IN) {
22480                 if (r->in.handle == NULL) {
22481                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22482                 }
22483                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22487                 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));
22488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22491                 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));
22492         }
22493         if (flags & NDR_OUT) {
22494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22495         }
22496         return NDR_ERR_SUCCESS;
22497 }
22498
22499 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
22500 {
22501         TALLOC_CTX *_mem_save_handle_0;
22502         if (flags & NDR_IN) {
22503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22504                         NDR_PULL_ALLOC(ndr, r->in.handle);
22505                 }
22506                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22507                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22508                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22510                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22511                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22512                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22513                         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));
22514                 }
22515                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22516                 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));
22517                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22518                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22519                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22520                         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));
22521                 }
22522                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22523                 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));
22524         }
22525         if (flags & NDR_OUT) {
22526                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22527         }
22528         return NDR_ERR_SUCCESS;
22529 }
22530
22531 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
22532 {
22533         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
22534         ndr->depth++;
22535         if (flags & NDR_SET_VALUES) {
22536                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22537         }
22538         if (flags & NDR_IN) {
22539                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
22540                 ndr->depth++;
22541                 ndr_print_ptr(ndr, "handle", r->in.handle);
22542                 ndr->depth++;
22543                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22544                 ndr->depth--;
22545                 ndr_print_string(ndr, "key_name", r->in.key_name);
22546                 ndr_print_string(ndr, "value_name", r->in.value_name);
22547                 ndr->depth--;
22548         }
22549         if (flags & NDR_OUT) {
22550                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
22551                 ndr->depth++;
22552                 ndr_print_WERROR(ndr, "result", r->out.result);
22553                 ndr->depth--;
22554         }
22555         ndr->depth--;
22556 }
22557
22558 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
22559 {
22560         if (flags & NDR_IN) {
22561                 if (r->in.handle == NULL) {
22562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22563                 }
22564                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22568                 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));
22569         }
22570         if (flags & NDR_OUT) {
22571                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22572         }
22573         return NDR_ERR_SUCCESS;
22574 }
22575
22576 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
22577 {
22578         TALLOC_CTX *_mem_save_handle_0;
22579         if (flags & NDR_IN) {
22580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22581                         NDR_PULL_ALLOC(ndr, r->in.handle);
22582                 }
22583                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22584                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22585                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22587                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22588                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22589                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22590                         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));
22591                 }
22592                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22593                 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));
22594         }
22595         if (flags & NDR_OUT) {
22596                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22597         }
22598         return NDR_ERR_SUCCESS;
22599 }
22600
22601 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
22602 {
22603         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
22604         ndr->depth++;
22605         if (flags & NDR_SET_VALUES) {
22606                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22607         }
22608         if (flags & NDR_IN) {
22609                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
22610                 ndr->depth++;
22611                 ndr_print_ptr(ndr, "handle", r->in.handle);
22612                 ndr->depth++;
22613                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22614                 ndr->depth--;
22615                 ndr_print_string(ndr, "key_name", r->in.key_name);
22616                 ndr->depth--;
22617         }
22618         if (flags & NDR_OUT) {
22619                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
22620                 ndr->depth++;
22621                 ndr_print_WERROR(ndr, "result", r->out.result);
22622                 ndr->depth--;
22623         }
22624         ndr->depth--;
22625 }
22626
22627 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
22628 {
22629         if (flags & NDR_IN) {
22630         }
22631         if (flags & NDR_OUT) {
22632                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22633         }
22634         return NDR_ERR_SUCCESS;
22635 }
22636
22637 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
22638 {
22639         if (flags & NDR_IN) {
22640         }
22641         if (flags & NDR_OUT) {
22642                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22643         }
22644         return NDR_ERR_SUCCESS;
22645 }
22646
22647 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
22648 {
22649         ndr_print_struct(ndr, name, "spoolss_53");
22650         ndr->depth++;
22651         if (flags & NDR_SET_VALUES) {
22652                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22653         }
22654         if (flags & NDR_IN) {
22655                 ndr_print_struct(ndr, "in", "spoolss_53");
22656                 ndr->depth++;
22657                 ndr->depth--;
22658         }
22659         if (flags & NDR_OUT) {
22660                 ndr_print_struct(ndr, "out", "spoolss_53");
22661                 ndr->depth++;
22662                 ndr_print_WERROR(ndr, "result", r->out.result);
22663                 ndr->depth--;
22664         }
22665         ndr->depth--;
22666 }
22667
22668 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22669 {
22670         if (flags & NDR_IN) {
22671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22672                 if (r->in.server) {
22673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22677                 }
22678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22681                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22685                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22686                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
22687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
22688         }
22689         if (flags & NDR_OUT) {
22690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22691         }
22692         return NDR_ERR_SUCCESS;
22693 }
22694
22695 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
22696 {
22697         uint32_t _ptr_server;
22698         TALLOC_CTX *_mem_save_server_0;
22699         if (flags & NDR_IN) {
22700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22701                 if (_ptr_server) {
22702                         NDR_PULL_ALLOC(ndr, r->in.server);
22703                 } else {
22704                         r->in.server = NULL;
22705                 }
22706                 if (r->in.server) {
22707                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22708                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22709                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22710                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22711                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22712                                 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));
22713                         }
22714                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22715                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22717                 }
22718                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22719                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22720                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22721                         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));
22722                 }
22723                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22724                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22725                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22726                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22727                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22728                         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));
22729                 }
22730                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22731                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22732                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
22733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
22734         }
22735         if (flags & NDR_OUT) {
22736                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22737         }
22738         return NDR_ERR_SUCCESS;
22739 }
22740
22741 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22742 {
22743         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
22744         ndr->depth++;
22745         if (flags & NDR_SET_VALUES) {
22746                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22747         }
22748         if (flags & NDR_IN) {
22749                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
22750                 ndr->depth++;
22751                 ndr_print_ptr(ndr, "server", r->in.server);
22752                 ndr->depth++;
22753                 if (r->in.server) {
22754                         ndr_print_string(ndr, "server", r->in.server);
22755                 }
22756                 ndr->depth--;
22757                 ndr_print_string(ndr, "architecture", r->in.architecture);
22758                 ndr_print_string(ndr, "driver", r->in.driver);
22759                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
22760                 ndr_print_uint32(ndr, "version", r->in.version);
22761                 ndr->depth--;
22762         }
22763         if (flags & NDR_OUT) {
22764                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
22765                 ndr->depth++;
22766                 ndr_print_WERROR(ndr, "result", r->out.result);
22767                 ndr->depth--;
22768         }
22769         ndr->depth--;
22770 }
22771
22772 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
22773 {
22774         if (flags & NDR_IN) {
22775         }
22776         if (flags & NDR_OUT) {
22777                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22778         }
22779         return NDR_ERR_SUCCESS;
22780 }
22781
22782 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
22783 {
22784         if (flags & NDR_IN) {
22785         }
22786         if (flags & NDR_OUT) {
22787                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22788         }
22789         return NDR_ERR_SUCCESS;
22790 }
22791
22792 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
22793 {
22794         ndr_print_struct(ndr, name, "spoolss_55");
22795         ndr->depth++;
22796         if (flags & NDR_SET_VALUES) {
22797                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22798         }
22799         if (flags & NDR_IN) {
22800                 ndr_print_struct(ndr, "in", "spoolss_55");
22801                 ndr->depth++;
22802                 ndr->depth--;
22803         }
22804         if (flags & NDR_OUT) {
22805                 ndr_print_struct(ndr, "out", "spoolss_55");
22806                 ndr->depth++;
22807                 ndr_print_WERROR(ndr, "result", r->out.result);
22808                 ndr->depth--;
22809         }
22810         ndr->depth--;
22811 }
22812
22813 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
22814 {
22815         if (flags & NDR_IN) {
22816         }
22817         if (flags & NDR_OUT) {
22818                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22819         }
22820         return NDR_ERR_SUCCESS;
22821 }
22822
22823 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
22824 {
22825         if (flags & NDR_IN) {
22826         }
22827         if (flags & NDR_OUT) {
22828                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22829         }
22830         return NDR_ERR_SUCCESS;
22831 }
22832
22833 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
22834 {
22835         ndr_print_struct(ndr, name, "spoolss_56");
22836         ndr->depth++;
22837         if (flags & NDR_SET_VALUES) {
22838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22839         }
22840         if (flags & NDR_IN) {
22841                 ndr_print_struct(ndr, "in", "spoolss_56");
22842                 ndr->depth++;
22843                 ndr->depth--;
22844         }
22845         if (flags & NDR_OUT) {
22846                 ndr_print_struct(ndr, "out", "spoolss_56");
22847                 ndr->depth++;
22848                 ndr_print_WERROR(ndr, "result", r->out.result);
22849                 ndr->depth--;
22850         }
22851         ndr->depth--;
22852 }
22853
22854 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
22855 {
22856         if (flags & NDR_IN) {
22857         }
22858         if (flags & NDR_OUT) {
22859                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22860         }
22861         return NDR_ERR_SUCCESS;
22862 }
22863
22864 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
22865 {
22866         if (flags & NDR_IN) {
22867         }
22868         if (flags & NDR_OUT) {
22869                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22870         }
22871         return NDR_ERR_SUCCESS;
22872 }
22873
22874 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
22875 {
22876         ndr_print_struct(ndr, name, "spoolss_57");
22877         ndr->depth++;
22878         if (flags & NDR_SET_VALUES) {
22879                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22880         }
22881         if (flags & NDR_IN) {
22882                 ndr_print_struct(ndr, "in", "spoolss_57");
22883                 ndr->depth++;
22884                 ndr->depth--;
22885         }
22886         if (flags & NDR_OUT) {
22887                 ndr_print_struct(ndr, "out", "spoolss_57");
22888                 ndr->depth++;
22889                 ndr_print_WERROR(ndr, "result", r->out.result);
22890                 ndr->depth--;
22891         }
22892         ndr->depth--;
22893 }
22894
22895 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
22896 {
22897         if (flags & NDR_IN) {
22898                 if (r->in.handle == NULL) {
22899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22900                 }
22901                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22905                 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));
22906                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
22907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
22908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22909                 if (r->in.status_code == NULL) {
22910                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22911                 }
22912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
22913         }
22914         if (flags & NDR_OUT) {
22915                 if (r->out.out_data == NULL) {
22916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22917                 }
22918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22919                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
22920                 if (r->out.needed == NULL) {
22921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22922                 }
22923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22924                 if (r->out.status_code == NULL) {
22925                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22926                 }
22927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
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_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
22934 {
22935         TALLOC_CTX *_mem_save_handle_0;
22936         TALLOC_CTX *_mem_save_needed_0;
22937         TALLOC_CTX *_mem_save_status_code_0;
22938         if (flags & NDR_IN) {
22939                 ZERO_STRUCT(r->out);
22940
22941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22942                         NDR_PULL_ALLOC(ndr, r->in.handle);
22943                 }
22944                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22945                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22946                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22948                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
22949                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
22950                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
22951                         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));
22952                 }
22953                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
22954                 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));
22955                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
22956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
22957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
22958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22959                         NDR_PULL_ALLOC(ndr, r->in.status_code);
22960                 }
22961                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22962                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
22963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
22964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22965                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
22966                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
22967                 NDR_PULL_ALLOC(ndr, r->out.needed);
22968                 ZERO_STRUCTP(r->out.needed);
22969                 NDR_PULL_ALLOC(ndr, r->out.status_code);
22970                 *r->out.status_code = *r->in.status_code;
22971         }
22972         if (flags & NDR_OUT) {
22973                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
22974                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22975                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
22976                 }
22977                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
22978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22979                         NDR_PULL_ALLOC(ndr, r->out.needed);
22980                 }
22981                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22982                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22986                         NDR_PULL_ALLOC(ndr, r->out.status_code);
22987                 }
22988                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22989                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
22990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
22991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22992                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22993                 if (r->out.out_data) {
22994                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
22995                 }
22996         }
22997         return NDR_ERR_SUCCESS;
22998 }
22999
23000 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
23001 {
23002         ndr_print_struct(ndr, name, "spoolss_XcvData");
23003         ndr->depth++;
23004         if (flags & NDR_SET_VALUES) {
23005                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23006         }
23007         if (flags & NDR_IN) {
23008                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
23009                 ndr->depth++;
23010                 ndr_print_ptr(ndr, "handle", r->in.handle);
23011                 ndr->depth++;
23012                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23013                 ndr->depth--;
23014                 ndr_print_string(ndr, "function_name", r->in.function_name);
23015                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
23016                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
23017                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
23018                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
23019                 ndr->depth++;
23020                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
23021                 ndr->depth--;
23022                 ndr->depth--;
23023         }
23024         if (flags & NDR_OUT) {
23025                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
23026                 ndr->depth++;
23027                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
23028                 ndr->depth++;
23029                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
23030                 ndr->depth--;
23031                 ndr_print_ptr(ndr, "needed", r->out.needed);
23032                 ndr->depth++;
23033                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23034                 ndr->depth--;
23035                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
23036                 ndr->depth++;
23037                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
23038                 ndr->depth--;
23039                 ndr_print_WERROR(ndr, "result", r->out.result);
23040                 ndr->depth--;
23041         }
23042         ndr->depth--;
23043 }
23044
23045 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
23046 {
23047         if (flags & NDR_IN) {
23048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23049                 if (r->in.servername) {
23050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23054                 }
23055                 if (r->in.info_ctr == NULL) {
23056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23057                 }
23058                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
23059                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
23060         }
23061         if (flags & NDR_OUT) {
23062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23063         }
23064         return NDR_ERR_SUCCESS;
23065 }
23066
23067 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
23068 {
23069         uint32_t _ptr_servername;
23070         TALLOC_CTX *_mem_save_servername_0;
23071         TALLOC_CTX *_mem_save_info_ctr_0;
23072         if (flags & NDR_IN) {
23073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23074                 if (_ptr_servername) {
23075                         NDR_PULL_ALLOC(ndr, r->in.servername);
23076                 } else {
23077                         r->in.servername = NULL;
23078                 }
23079                 if (r->in.servername) {
23080                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23081                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23083                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23084                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23085                                 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));
23086                         }
23087                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23088                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23089                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23090                 }
23091                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23092                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
23093                 }
23094                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23095                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
23096                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
23097                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23098                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
23099         }
23100         if (flags & NDR_OUT) {
23101                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23102         }
23103         return NDR_ERR_SUCCESS;
23104 }
23105
23106 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
23107 {
23108         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
23109         ndr->depth++;
23110         if (flags & NDR_SET_VALUES) {
23111                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23112         }
23113         if (flags & NDR_IN) {
23114                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
23115                 ndr->depth++;
23116                 ndr_print_ptr(ndr, "servername", r->in.servername);
23117                 ndr->depth++;
23118                 if (r->in.servername) {
23119                         ndr_print_string(ndr, "servername", r->in.servername);
23120                 }
23121                 ndr->depth--;
23122                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
23123                 ndr->depth++;
23124                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
23125                 ndr->depth--;
23126                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
23127                 ndr->depth--;
23128         }
23129         if (flags & NDR_OUT) {
23130                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
23131                 ndr->depth++;
23132                 ndr_print_WERROR(ndr, "result", r->out.result);
23133                 ndr->depth--;
23134         }
23135         ndr->depth--;
23136 }
23137
23138 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
23139 {
23140         if (flags & NDR_IN) {
23141         }
23142         if (flags & NDR_OUT) {
23143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23144         }
23145         return NDR_ERR_SUCCESS;
23146 }
23147
23148 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
23149 {
23150         if (flags & NDR_IN) {
23151         }
23152         if (flags & NDR_OUT) {
23153                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23154         }
23155         return NDR_ERR_SUCCESS;
23156 }
23157
23158 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
23159 {
23160         ndr_print_struct(ndr, name, "spoolss_5a");
23161         ndr->depth++;
23162         if (flags & NDR_SET_VALUES) {
23163                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23164         }
23165         if (flags & NDR_IN) {
23166                 ndr_print_struct(ndr, "in", "spoolss_5a");
23167                 ndr->depth++;
23168                 ndr->depth--;
23169         }
23170         if (flags & NDR_OUT) {
23171                 ndr_print_struct(ndr, "out", "spoolss_5a");
23172                 ndr->depth++;
23173                 ndr_print_WERROR(ndr, "result", r->out.result);
23174                 ndr->depth--;
23175         }
23176         ndr->depth--;
23177 }
23178
23179 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
23180 {
23181         if (flags & NDR_IN) {
23182         }
23183         if (flags & NDR_OUT) {
23184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23185         }
23186         return NDR_ERR_SUCCESS;
23187 }
23188
23189 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
23190 {
23191         if (flags & NDR_IN) {
23192         }
23193         if (flags & NDR_OUT) {
23194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23195         }
23196         return NDR_ERR_SUCCESS;
23197 }
23198
23199 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
23200 {
23201         ndr_print_struct(ndr, name, "spoolss_5b");
23202         ndr->depth++;
23203         if (flags & NDR_SET_VALUES) {
23204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23205         }
23206         if (flags & NDR_IN) {
23207                 ndr_print_struct(ndr, "in", "spoolss_5b");
23208                 ndr->depth++;
23209                 ndr->depth--;
23210         }
23211         if (flags & NDR_OUT) {
23212                 ndr_print_struct(ndr, "out", "spoolss_5b");
23213                 ndr->depth++;
23214                 ndr_print_WERROR(ndr, "result", r->out.result);
23215                 ndr->depth--;
23216         }
23217         ndr->depth--;
23218 }
23219
23220 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
23221 {
23222         if (flags & NDR_IN) {
23223         }
23224         if (flags & NDR_OUT) {
23225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23226         }
23227         return NDR_ERR_SUCCESS;
23228 }
23229
23230 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
23231 {
23232         if (flags & NDR_IN) {
23233         }
23234         if (flags & NDR_OUT) {
23235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23236         }
23237         return NDR_ERR_SUCCESS;
23238 }
23239
23240 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
23241 {
23242         ndr_print_struct(ndr, name, "spoolss_5c");
23243         ndr->depth++;
23244         if (flags & NDR_SET_VALUES) {
23245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23246         }
23247         if (flags & NDR_IN) {
23248                 ndr_print_struct(ndr, "in", "spoolss_5c");
23249                 ndr->depth++;
23250                 ndr->depth--;
23251         }
23252         if (flags & NDR_OUT) {
23253                 ndr_print_struct(ndr, "out", "spoolss_5c");
23254                 ndr->depth++;
23255                 ndr_print_WERROR(ndr, "result", r->out.result);
23256                 ndr->depth--;
23257         }
23258         ndr->depth--;
23259 }
23260
23261 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
23262 {
23263         if (flags & NDR_IN) {
23264         }
23265         if (flags & NDR_OUT) {
23266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23267         }
23268         return NDR_ERR_SUCCESS;
23269 }
23270
23271 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
23272 {
23273         if (flags & NDR_IN) {
23274         }
23275         if (flags & NDR_OUT) {
23276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23277         }
23278         return NDR_ERR_SUCCESS;
23279 }
23280
23281 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
23282 {
23283         ndr_print_struct(ndr, name, "spoolss_5d");
23284         ndr->depth++;
23285         if (flags & NDR_SET_VALUES) {
23286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23287         }
23288         if (flags & NDR_IN) {
23289                 ndr_print_struct(ndr, "in", "spoolss_5d");
23290                 ndr->depth++;
23291                 ndr->depth--;
23292         }
23293         if (flags & NDR_OUT) {
23294                 ndr_print_struct(ndr, "out", "spoolss_5d");
23295                 ndr->depth++;
23296                 ndr_print_WERROR(ndr, "result", r->out.result);
23297                 ndr->depth--;
23298         }
23299         ndr->depth--;
23300 }
23301
23302 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
23303 {
23304         if (flags & NDR_IN) {
23305         }
23306         if (flags & NDR_OUT) {
23307                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23308         }
23309         return NDR_ERR_SUCCESS;
23310 }
23311
23312 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
23313 {
23314         if (flags & NDR_IN) {
23315         }
23316         if (flags & NDR_OUT) {
23317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23318         }
23319         return NDR_ERR_SUCCESS;
23320 }
23321
23322 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
23323 {
23324         ndr_print_struct(ndr, name, "spoolss_5e");
23325         ndr->depth++;
23326         if (flags & NDR_SET_VALUES) {
23327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23328         }
23329         if (flags & NDR_IN) {
23330                 ndr_print_struct(ndr, "in", "spoolss_5e");
23331                 ndr->depth++;
23332                 ndr->depth--;
23333         }
23334         if (flags & NDR_OUT) {
23335                 ndr_print_struct(ndr, "out", "spoolss_5e");
23336                 ndr->depth++;
23337                 ndr_print_WERROR(ndr, "result", r->out.result);
23338                 ndr->depth--;
23339         }
23340         ndr->depth--;
23341 }
23342
23343 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
23344 {
23345         if (flags & NDR_IN) {
23346         }
23347         if (flags & NDR_OUT) {
23348                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23349         }
23350         return NDR_ERR_SUCCESS;
23351 }
23352
23353 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
23354 {
23355         if (flags & NDR_IN) {
23356         }
23357         if (flags & NDR_OUT) {
23358                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23359         }
23360         return NDR_ERR_SUCCESS;
23361 }
23362
23363 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
23364 {
23365         ndr_print_struct(ndr, name, "spoolss_5f");
23366         ndr->depth++;
23367         if (flags & NDR_SET_VALUES) {
23368                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23369         }
23370         if (flags & NDR_IN) {
23371                 ndr_print_struct(ndr, "in", "spoolss_5f");
23372                 ndr->depth++;
23373                 ndr->depth--;
23374         }
23375         if (flags & NDR_OUT) {
23376                 ndr_print_struct(ndr, "out", "spoolss_5f");
23377                 ndr->depth++;
23378                 ndr_print_WERROR(ndr, "result", r->out.result);
23379                 ndr->depth--;
23380         }
23381         ndr->depth--;
23382 }
23383
23384 static const struct ndr_interface_call spoolss_calls[] = {
23385         {
23386                 "spoolss_EnumPrinters",
23387                 sizeof(struct spoolss_EnumPrinters),
23388                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
23389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
23390                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
23391                 false,
23392         },
23393         {
23394                 "spoolss_OpenPrinter",
23395                 sizeof(struct spoolss_OpenPrinter),
23396                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
23397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
23398                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
23399                 false,
23400         },
23401         {
23402                 "spoolss_SetJob",
23403                 sizeof(struct spoolss_SetJob),
23404                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
23405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
23406                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
23407                 false,
23408         },
23409         {
23410                 "spoolss_GetJob",
23411                 sizeof(struct spoolss_GetJob),
23412                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
23413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
23414                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
23415                 false,
23416         },
23417         {
23418                 "spoolss_EnumJobs",
23419                 sizeof(struct spoolss_EnumJobs),
23420                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
23421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
23422                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
23423                 false,
23424         },
23425         {
23426                 "spoolss_AddPrinter",
23427                 sizeof(struct spoolss_AddPrinter),
23428                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
23429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
23430                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
23431                 false,
23432         },
23433         {
23434                 "spoolss_DeletePrinter",
23435                 sizeof(struct spoolss_DeletePrinter),
23436                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
23437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
23438                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
23439                 false,
23440         },
23441         {
23442                 "spoolss_SetPrinter",
23443                 sizeof(struct spoolss_SetPrinter),
23444                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
23445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
23446                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
23447                 false,
23448         },
23449         {
23450                 "spoolss_GetPrinter",
23451                 sizeof(struct spoolss_GetPrinter),
23452                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
23453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
23454                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
23455                 false,
23456         },
23457         {
23458                 "spoolss_AddPrinterDriver",
23459                 sizeof(struct spoolss_AddPrinterDriver),
23460                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
23461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
23462                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
23463                 false,
23464         },
23465         {
23466                 "spoolss_EnumPrinterDrivers",
23467                 sizeof(struct spoolss_EnumPrinterDrivers),
23468                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
23469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
23470                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
23471                 false,
23472         },
23473         {
23474                 "spoolss_GetPrinterDriver",
23475                 sizeof(struct spoolss_GetPrinterDriver),
23476                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
23477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
23478                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
23479                 false,
23480         },
23481         {
23482                 "spoolss_GetPrinterDriverDirectory",
23483                 sizeof(struct spoolss_GetPrinterDriverDirectory),
23484                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
23485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
23486                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
23487                 false,
23488         },
23489         {
23490                 "spoolss_DeletePrinterDriver",
23491                 sizeof(struct spoolss_DeletePrinterDriver),
23492                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
23493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
23494                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
23495                 false,
23496         },
23497         {
23498                 "spoolss_AddPrintProcessor",
23499                 sizeof(struct spoolss_AddPrintProcessor),
23500                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
23501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
23502                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
23503                 false,
23504         },
23505         {
23506                 "spoolss_EnumPrintProcessors",
23507                 sizeof(struct spoolss_EnumPrintProcessors),
23508                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
23509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
23510                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
23511                 false,
23512         },
23513         {
23514                 "spoolss_GetPrintProcessorDirectory",
23515                 sizeof(struct spoolss_GetPrintProcessorDirectory),
23516                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
23517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
23518                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
23519                 false,
23520         },
23521         {
23522                 "spoolss_StartDocPrinter",
23523                 sizeof(struct spoolss_StartDocPrinter),
23524                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
23525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
23526                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
23527                 false,
23528         },
23529         {
23530                 "spoolss_StartPagePrinter",
23531                 sizeof(struct spoolss_StartPagePrinter),
23532                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
23533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
23534                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
23535                 false,
23536         },
23537         {
23538                 "spoolss_WritePrinter",
23539                 sizeof(struct spoolss_WritePrinter),
23540                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
23541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
23542                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
23543                 false,
23544         },
23545         {
23546                 "spoolss_EndPagePrinter",
23547                 sizeof(struct spoolss_EndPagePrinter),
23548                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
23549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
23550                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
23551                 false,
23552         },
23553         {
23554                 "spoolss_AbortPrinter",
23555                 sizeof(struct spoolss_AbortPrinter),
23556                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
23557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
23558                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
23559                 false,
23560         },
23561         {
23562                 "spoolss_ReadPrinter",
23563                 sizeof(struct spoolss_ReadPrinter),
23564                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
23565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
23566                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
23567                 false,
23568         },
23569         {
23570                 "spoolss_EndDocPrinter",
23571                 sizeof(struct spoolss_EndDocPrinter),
23572                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
23573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
23574                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
23575                 false,
23576         },
23577         {
23578                 "spoolss_AddJob",
23579                 sizeof(struct spoolss_AddJob),
23580                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
23581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
23582                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
23583                 false,
23584         },
23585         {
23586                 "spoolss_ScheduleJob",
23587                 sizeof(struct spoolss_ScheduleJob),
23588                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
23589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
23590                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
23591                 false,
23592         },
23593         {
23594                 "spoolss_GetPrinterData",
23595                 sizeof(struct spoolss_GetPrinterData),
23596                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
23597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
23598                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
23599                 false,
23600         },
23601         {
23602                 "spoolss_SetPrinterData",
23603                 sizeof(struct spoolss_SetPrinterData),
23604                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
23605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
23606                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
23607                 false,
23608         },
23609         {
23610                 "spoolss_WaitForPrinterChange",
23611                 sizeof(struct spoolss_WaitForPrinterChange),
23612                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
23613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
23614                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
23615                 false,
23616         },
23617         {
23618                 "spoolss_ClosePrinter",
23619                 sizeof(struct spoolss_ClosePrinter),
23620                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
23621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
23622                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
23623                 false,
23624         },
23625         {
23626                 "spoolss_AddForm",
23627                 sizeof(struct spoolss_AddForm),
23628                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
23629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
23630                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
23631                 false,
23632         },
23633         {
23634                 "spoolss_DeleteForm",
23635                 sizeof(struct spoolss_DeleteForm),
23636                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
23637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
23638                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
23639                 false,
23640         },
23641         {
23642                 "spoolss_GetForm",
23643                 sizeof(struct spoolss_GetForm),
23644                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
23645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
23646                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
23647                 false,
23648         },
23649         {
23650                 "spoolss_SetForm",
23651                 sizeof(struct spoolss_SetForm),
23652                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
23653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
23654                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
23655                 false,
23656         },
23657         {
23658                 "spoolss_EnumForms",
23659                 sizeof(struct spoolss_EnumForms),
23660                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
23661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
23662                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
23663                 false,
23664         },
23665         {
23666                 "spoolss_EnumPorts",
23667                 sizeof(struct spoolss_EnumPorts),
23668                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
23669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
23670                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
23671                 false,
23672         },
23673         {
23674                 "spoolss_EnumMonitors",
23675                 sizeof(struct spoolss_EnumMonitors),
23676                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
23677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
23678                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
23679                 false,
23680         },
23681         {
23682                 "spoolss_AddPort",
23683                 sizeof(struct spoolss_AddPort),
23684                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
23685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
23686                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
23687                 false,
23688         },
23689         {
23690                 "spoolss_ConfigurePort",
23691                 sizeof(struct spoolss_ConfigurePort),
23692                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
23693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
23694                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
23695                 false,
23696         },
23697         {
23698                 "spoolss_DeletePort",
23699                 sizeof(struct spoolss_DeletePort),
23700                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
23701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
23702                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
23703                 false,
23704         },
23705         {
23706                 "spoolss_CreatePrinterIC",
23707                 sizeof(struct spoolss_CreatePrinterIC),
23708                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
23709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
23710                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
23711                 false,
23712         },
23713         {
23714                 "spoolss_PlayGDIScriptOnPrinterIC",
23715                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
23716                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
23717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
23718                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
23719                 false,
23720         },
23721         {
23722                 "spoolss_DeletePrinterIC",
23723                 sizeof(struct spoolss_DeletePrinterIC),
23724                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
23725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
23726                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
23727                 false,
23728         },
23729         {
23730                 "spoolss_AddPrinterConnection",
23731                 sizeof(struct spoolss_AddPrinterConnection),
23732                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
23733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
23734                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
23735                 false,
23736         },
23737         {
23738                 "spoolss_DeletePrinterConnection",
23739                 sizeof(struct spoolss_DeletePrinterConnection),
23740                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
23741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
23742                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
23743                 false,
23744         },
23745         {
23746                 "spoolss_PrinterMessageBox",
23747                 sizeof(struct spoolss_PrinterMessageBox),
23748                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
23749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
23750                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
23751                 false,
23752         },
23753         {
23754                 "spoolss_AddMonitor",
23755                 sizeof(struct spoolss_AddMonitor),
23756                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
23757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
23758                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
23759                 false,
23760         },
23761         {
23762                 "spoolss_DeleteMonitor",
23763                 sizeof(struct spoolss_DeleteMonitor),
23764                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
23765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
23766                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
23767                 false,
23768         },
23769         {
23770                 "spoolss_DeletePrintProcessor",
23771                 sizeof(struct spoolss_DeletePrintProcessor),
23772                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
23773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
23774                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
23775                 false,
23776         },
23777         {
23778                 "spoolss_AddPrintProvidor",
23779                 sizeof(struct spoolss_AddPrintProvidor),
23780                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
23781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
23782                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
23783                 false,
23784         },
23785         {
23786                 "spoolss_DeletePrintProvidor",
23787                 sizeof(struct spoolss_DeletePrintProvidor),
23788                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
23789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
23790                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
23791                 false,
23792         },
23793         {
23794                 "spoolss_EnumPrintProcDataTypes",
23795                 sizeof(struct spoolss_EnumPrintProcDataTypes),
23796                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
23797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
23798                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
23799                 false,
23800         },
23801         {
23802                 "spoolss_ResetPrinter",
23803                 sizeof(struct spoolss_ResetPrinter),
23804                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
23805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
23806                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
23807                 false,
23808         },
23809         {
23810                 "spoolss_GetPrinterDriver2",
23811                 sizeof(struct spoolss_GetPrinterDriver2),
23812                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
23813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
23814                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
23815                 false,
23816         },
23817         {
23818                 "spoolss_FindFirstPrinterChangeNotification",
23819                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
23820                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
23821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
23822                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
23823                 false,
23824         },
23825         {
23826                 "spoolss_FindNextPrinterChangeNotification",
23827                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
23828                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
23829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
23830                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
23831                 false,
23832         },
23833         {
23834                 "spoolss_FindClosePrinterNotify",
23835                 sizeof(struct spoolss_FindClosePrinterNotify),
23836                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
23837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
23838                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
23839                 false,
23840         },
23841         {
23842                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
23843                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
23844                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23846                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23847                 false,
23848         },
23849         {
23850                 "spoolss_ReplyOpenPrinter",
23851                 sizeof(struct spoolss_ReplyOpenPrinter),
23852                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
23853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
23854                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
23855                 false,
23856         },
23857         {
23858                 "spoolss_RouterReplyPrinter",
23859                 sizeof(struct spoolss_RouterReplyPrinter),
23860                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
23861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
23862                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
23863                 false,
23864         },
23865         {
23866                 "spoolss_ReplyClosePrinter",
23867                 sizeof(struct spoolss_ReplyClosePrinter),
23868                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
23869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
23870                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
23871                 false,
23872         },
23873         {
23874                 "spoolss_AddPortEx",
23875                 sizeof(struct spoolss_AddPortEx),
23876                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
23877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
23878                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
23879                 false,
23880         },
23881         {
23882                 "spoolss_RouterFindFirstPrinterChangeNotification",
23883                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
23884                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
23885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
23886                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
23887                 false,
23888         },
23889         {
23890                 "spoolss_SpoolerInit",
23891                 sizeof(struct spoolss_SpoolerInit),
23892                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
23893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
23894                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
23895                 false,
23896         },
23897         {
23898                 "spoolss_ResetPrinterEx",
23899                 sizeof(struct spoolss_ResetPrinterEx),
23900                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
23901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
23902                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
23903                 false,
23904         },
23905         {
23906                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
23907                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
23908                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23910                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23911                 false,
23912         },
23913         {
23914                 "spoolss_RouterReplyPrinterEx",
23915                 sizeof(struct spoolss_RouterReplyPrinterEx),
23916                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
23917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
23918                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
23919                 false,
23920         },
23921         {
23922                 "spoolss_RouterRefreshPrinterChangeNotify",
23923                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
23924                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
23925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
23926                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
23927                 false,
23928         },
23929         {
23930                 "spoolss_44",
23931                 sizeof(struct spoolss_44),
23932                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
23933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
23934                 (ndr_print_function_t) ndr_print_spoolss_44,
23935                 false,
23936         },
23937         {
23938                 "spoolss_OpenPrinterEx",
23939                 sizeof(struct spoolss_OpenPrinterEx),
23940                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
23941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
23942                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
23943                 false,
23944         },
23945         {
23946                 "spoolss_AddPrinterEx",
23947                 sizeof(struct spoolss_AddPrinterEx),
23948                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
23949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
23950                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
23951                 false,
23952         },
23953         {
23954                 "spoolss_47",
23955                 sizeof(struct spoolss_47),
23956                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
23957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
23958                 (ndr_print_function_t) ndr_print_spoolss_47,
23959                 false,
23960         },
23961         {
23962                 "spoolss_EnumPrinterData",
23963                 sizeof(struct spoolss_EnumPrinterData),
23964                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
23965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
23966                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
23967                 false,
23968         },
23969         {
23970                 "spoolss_DeletePrinterData",
23971                 sizeof(struct spoolss_DeletePrinterData),
23972                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
23973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
23974                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
23975                 false,
23976         },
23977         {
23978                 "spoolss_4a",
23979                 sizeof(struct spoolss_4a),
23980                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
23981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
23982                 (ndr_print_function_t) ndr_print_spoolss_4a,
23983                 false,
23984         },
23985         {
23986                 "spoolss_4b",
23987                 sizeof(struct spoolss_4b),
23988                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
23989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
23990                 (ndr_print_function_t) ndr_print_spoolss_4b,
23991                 false,
23992         },
23993         {
23994                 "spoolss_4c",
23995                 sizeof(struct spoolss_4c),
23996                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
23997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
23998                 (ndr_print_function_t) ndr_print_spoolss_4c,
23999                 false,
24000         },
24001         {
24002                 "spoolss_SetPrinterDataEx",
24003                 sizeof(struct spoolss_SetPrinterDataEx),
24004                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
24005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
24006                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
24007                 false,
24008         },
24009         {
24010                 "spoolss_GetPrinterDataEx",
24011                 sizeof(struct spoolss_GetPrinterDataEx),
24012                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
24013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
24014                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
24015                 false,
24016         },
24017         {
24018                 "spoolss_EnumPrinterDataEx",
24019                 sizeof(struct spoolss_EnumPrinterDataEx),
24020                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
24021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
24022                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
24023                 false,
24024         },
24025         {
24026                 "spoolss_EnumPrinterKey",
24027                 sizeof(struct spoolss_EnumPrinterKey),
24028                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
24029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
24030                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
24031                 false,
24032         },
24033         {
24034                 "spoolss_DeletePrinterDataEx",
24035                 sizeof(struct spoolss_DeletePrinterDataEx),
24036                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
24037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
24038                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
24039                 false,
24040         },
24041         {
24042                 "spoolss_DeletePrinterKey",
24043                 sizeof(struct spoolss_DeletePrinterKey),
24044                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
24045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
24046                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
24047                 false,
24048         },
24049         {
24050                 "spoolss_53",
24051                 sizeof(struct spoolss_53),
24052                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
24053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
24054                 (ndr_print_function_t) ndr_print_spoolss_53,
24055                 false,
24056         },
24057         {
24058                 "spoolss_DeletePrinterDriverEx",
24059                 sizeof(struct spoolss_DeletePrinterDriverEx),
24060                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
24061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
24062                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
24063                 false,
24064         },
24065         {
24066                 "spoolss_55",
24067                 sizeof(struct spoolss_55),
24068                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
24069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
24070                 (ndr_print_function_t) ndr_print_spoolss_55,
24071                 false,
24072         },
24073         {
24074                 "spoolss_56",
24075                 sizeof(struct spoolss_56),
24076                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
24077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
24078                 (ndr_print_function_t) ndr_print_spoolss_56,
24079                 false,
24080         },
24081         {
24082                 "spoolss_57",
24083                 sizeof(struct spoolss_57),
24084                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
24085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
24086                 (ndr_print_function_t) ndr_print_spoolss_57,
24087                 false,
24088         },
24089         {
24090                 "spoolss_XcvData",
24091                 sizeof(struct spoolss_XcvData),
24092                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
24093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
24094                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
24095                 false,
24096         },
24097         {
24098                 "spoolss_AddPrinterDriverEx",
24099                 sizeof(struct spoolss_AddPrinterDriverEx),
24100                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
24101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
24102                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
24103                 false,
24104         },
24105         {
24106                 "spoolss_5a",
24107                 sizeof(struct spoolss_5a),
24108                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
24109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
24110                 (ndr_print_function_t) ndr_print_spoolss_5a,
24111                 false,
24112         },
24113         {
24114                 "spoolss_5b",
24115                 sizeof(struct spoolss_5b),
24116                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
24117                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
24118                 (ndr_print_function_t) ndr_print_spoolss_5b,
24119                 false,
24120         },
24121         {
24122                 "spoolss_5c",
24123                 sizeof(struct spoolss_5c),
24124                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
24125                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
24126                 (ndr_print_function_t) ndr_print_spoolss_5c,
24127                 false,
24128         },
24129         {
24130                 "spoolss_5d",
24131                 sizeof(struct spoolss_5d),
24132                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
24133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
24134                 (ndr_print_function_t) ndr_print_spoolss_5d,
24135                 false,
24136         },
24137         {
24138                 "spoolss_5e",
24139                 sizeof(struct spoolss_5e),
24140                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
24141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
24142                 (ndr_print_function_t) ndr_print_spoolss_5e,
24143                 false,
24144         },
24145         {
24146                 "spoolss_5f",
24147                 sizeof(struct spoolss_5f),
24148                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
24149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
24150                 (ndr_print_function_t) ndr_print_spoolss_5f,
24151                 false,
24152         },
24153         { NULL, 0, NULL, NULL, NULL, false }
24154 };
24155
24156 static const char * const spoolss_endpoint_strings[] = {
24157         "ncacn_np:[\\pipe\\spoolss]",
24158 };
24159
24160 static const struct ndr_interface_string_array spoolss_endpoints = {
24161         .count  = 1,
24162         .names  = spoolss_endpoint_strings
24163 };
24164
24165 static const char * const spoolss_authservice_strings[] = {
24166         "host",
24167 };
24168
24169 static const struct ndr_interface_string_array spoolss_authservices = {
24170         .count  = 1,
24171         .names  = spoolss_authservice_strings
24172 };
24173
24174
24175 const struct ndr_interface_table ndr_table_spoolss = {
24176         .name           = "spoolss",
24177         .syntax_id      = {
24178                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
24179                 NDR_SPOOLSS_VERSION
24180         },
24181         .helpstring     = NDR_SPOOLSS_HELPSTRING,
24182         .num_calls      = 96,
24183         .calls          = spoolss_calls,
24184         .endpoints      = &spoolss_endpoints,
24185         .authservices   = &spoolss_authservices
24186 };
24187