librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 228 {
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_push_align(ndr, 4));
 231                 {
 232                         uint32_t _flags_save_string = ndr->flags;
 233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 235                         ndr->flags = _flags_save_string;
 236                 }
 237                 {
 238                         uint32_t _flags_save_string = ndr->flags;
 239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 241                         ndr->flags = _flags_save_string;
 242                 }
 243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 246                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
 257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 258                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 265                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 270         }
 271         if (ndr_flags & NDR_BUFFERS) {
 272                 {
 273                         uint32_t _flags_save_string = ndr->flags;
 274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 275                         if (r->printername) {
 276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 278                         }
 279                         ndr->flags = _flags_save_string;
 280                 }
 281                 {
 282                         uint32_t _flags_save_string = ndr->flags;
 283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 284                         if (r->servername) {
 285                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 286                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 287                         }
 288                         ndr->flags = _flags_save_string;
 289                 }
 290         }
 291         return NDR_ERR_SUCCESS;
 292 }
 293
 294 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 295 {
 296         uint32_t _ptr_printername;
 297         TALLOC_CTX *_mem_save_printername_0;
 298         uint32_t _ptr_servername;
 299         TALLOC_CTX *_mem_save_servername_0;
 300         if (ndr_flags & NDR_SCALARS) {
 301                 NDR_CHECK(ndr_pull_align(ndr, 4));
 302                 {
 303                         uint32_t _flags_save_string = ndr->flags;
 304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 306                         if (_ptr_printername) {
 307                                 NDR_PULL_ALLOC(ndr, r->printername);
 308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 309                         } else {
 310                                 r->printername = NULL;
 311                         }
 312                         ndr->flags = _flags_save_string;
 313                 }
 314                 {
 315                         uint32_t _flags_save_string = ndr->flags;
 316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 318                         if (_ptr_servername) {
 319                                 NDR_PULL_ALLOC(ndr, r->servername);
 320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 321                         } else {
 322                                 r->servername = NULL;
 323                         }
 324                         ndr->flags = _flags_save_string;
 325                 }
 326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 329                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
 340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 341                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 348                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 349                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 353         }
 354         if (ndr_flags & NDR_BUFFERS) {
 355                 {
 356                         uint32_t _flags_save_string = ndr->flags;
 357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 358                         if (r->printername) {
 359                                 uint32_t _relative_save_offset;
 360                                 _relative_save_offset = ndr->offset;
 361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 362                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 363                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 366                                 ndr->offset = _relative_save_offset;
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370                 {
 371                         uint32_t _flags_save_string = ndr->flags;
 372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 373                         if (r->servername) {
 374                                 uint32_t _relative_save_offset;
 375                                 _relative_save_offset = ndr->offset;
 376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 377                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 378                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 379                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 381                                 ndr->offset = _relative_save_offset;
 382                         }
 383                         ndr->flags = _flags_save_string;
 384                 }
 385         }
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 390 {
 391         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 392         ndr->depth++;
 393         ndr_print_ptr(ndr, "printername", r->printername);
 394         ndr->depth++;
 395         if (r->printername) {
 396                 ndr_print_string(ndr, "printername", r->printername);
 397         }
 398         ndr->depth--;
 399         ndr_print_ptr(ndr, "servername", r->servername);
 400         ndr->depth++;
 401         if (r->servername) {
 402                 ndr_print_string(ndr, "servername", r->servername);
 403         }
 404         ndr->depth--;
 405         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 406         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 407         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 408         ndr_print_spoolss_Time(ndr, "time", &r->time);
 409         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 410         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 411         ndr_print_uint32(ndr, "version", r->version);
 412         ndr_print_uint32(ndr, "free_build", r->free_build);
 413         ndr_print_uint32(ndr, "spooling", r->spooling);
 414         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 415         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 416         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 417         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 418         ndr_print_uint32(ndr, "job_error", r->job_error);
 419         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 420         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 421         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 422         ndr_print_uint32(ndr, "change_id", r->change_id);
 423         ndr_print_WERROR(ndr, "last_error", r->last_error);
 424         ndr_print_uint32(ndr, "status", r->status);
 425         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 426         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 427         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 428         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 429         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 430         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 431         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 432         ndr->depth--;
 433 }
 434
 435 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 436 {
 437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 438         return NDR_ERR_SUCCESS;
 439 }
 440
 441 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 442 {
 443         uint32_t v;
 444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 445         *r = v;
 446         return NDR_ERR_SUCCESS;
 447 }
 448
 449 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 450 {
 451         ndr_print_uint32(ndr, name, r);
 452         ndr->depth++;
 453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 464         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 465         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 466         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 467         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 468         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 469         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 470         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 474         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 478         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 480         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 481         ndr->depth--;
 482 }
 483
 484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 485 {
 486         if (ndr_flags & NDR_SCALARS) {
 487                 NDR_CHECK(ndr_push_align(ndr, 4));
 488                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 489                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 490                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 491                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 492                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 493                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 494                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 496                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 497                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 498                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 499                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 500                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 501                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 502                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 503                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 504                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 505                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 506                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 507                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 508                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 522                 {
 523                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 525                         {
 526                                 struct ndr_push *_ndr_driverextra_data;
 527                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 528                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 529                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 530                         }
 531                         ndr->flags = _flags_save_DATA_BLOB;
 532                 }
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535         }
 536         return NDR_ERR_SUCCESS;
 537 }
 538
 539 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 540 {
 541         if (ndr_flags & NDR_SCALARS) {
 542                 NDR_CHECK(ndr_pull_align(ndr, 4));
 543                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 544                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 545                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 546                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 547                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 548                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 549                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 550                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 551                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 552                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 553                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 554                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 555                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 556                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 557                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 558                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 559                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 560                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 562                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 563                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 577                 {
 578                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 580                         {
 581                                 struct ndr_pull *_ndr_driverextra_data;
 582                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 583                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 584                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 585                         }
 586                         ndr->flags = _flags_save_DATA_BLOB;
 587                 }
 588         }
 589         if (ndr_flags & NDR_BUFFERS) {
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 595 {
 596         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 597         ndr->depth++;
 598         ndr_print_string(ndr, "devicename", r->devicename);
 599         ndr_print_uint16(ndr, "specversion", r->specversion);
 600         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 601         ndr_print_uint16(ndr, "size", r->size);
 602         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 603         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 604         ndr_print_uint16(ndr, "orientation", r->orientation);
 605         ndr_print_uint16(ndr, "papersize", r->papersize);
 606         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 607         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 608         ndr_print_uint16(ndr, "scale", r->scale);
 609         ndr_print_uint16(ndr, "copies", r->copies);
 610         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 611         ndr_print_uint16(ndr, "printquality", r->printquality);
 612         ndr_print_uint16(ndr, "color", r->color);
 613         ndr_print_uint16(ndr, "duplex", r->duplex);
 614         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 615         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 616         ndr_print_uint16(ndr, "collate", r->collate);
 617         ndr_print_string(ndr, "formname", r->formname);
 618         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 619         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 620         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 621         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 622         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 623         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 624         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 625         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 626         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 627         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 628         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 629         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 630         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 631         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 632         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 633         ndr->depth--;
 634 }
 635
 636 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 637 {
 638         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 639 }
 640
 641 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 642 {
 643         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 644         return NDR_ERR_SUCCESS;
 645 }
 646
 647 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 648 {
 649         uint32_t v;
 650         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 651         *r = v;
 652         return NDR_ERR_SUCCESS;
 653 }
 654
 655 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 656 {
 657         ndr_print_uint32(ndr, name, r);
 658         ndr->depth++;
 659         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 660         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 678         ndr->depth--;
 679 }
 680
 681 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 682 {
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_push_align(ndr, 4));
 685                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 686                 {
 687                         uint32_t _flags_save_string = ndr->flags;
 688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 689                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 690                         ndr->flags = _flags_save_string;
 691                 }
 692                 {
 693                         uint32_t _flags_save_string = ndr->flags;
 694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 695                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 696                         ndr->flags = _flags_save_string;
 697                 }
 698                 {
 699                         uint32_t _flags_save_string = ndr->flags;
 700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 701                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 702                         ndr->flags = _flags_save_string;
 703                 }
 704         }
 705         if (ndr_flags & NDR_BUFFERS) {
 706                 {
 707                         uint32_t _flags_save_string = ndr->flags;
 708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 709                         if (r->name) {
 710                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 712                         }
 713                         ndr->flags = _flags_save_string;
 714                 }
 715                 {
 716                         uint32_t _flags_save_string = ndr->flags;
 717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 718                         if (r->description) {
 719                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 720                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 721                         }
 722                         ndr->flags = _flags_save_string;
 723                 }
 724                 {
 725                         uint32_t _flags_save_string = ndr->flags;
 726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 727                         if (r->comment) {
 728                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 730                         }
 731                         ndr->flags = _flags_save_string;
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 738 {
 739         uint32_t _ptr_name;
 740         TALLOC_CTX *_mem_save_name_0;
 741         uint32_t _ptr_description;
 742         TALLOC_CTX *_mem_save_description_0;
 743         uint32_t _ptr_comment;
 744         TALLOC_CTX *_mem_save_comment_0;
 745         if (ndr_flags & NDR_SCALARS) {
 746                 NDR_CHECK(ndr_pull_align(ndr, 4));
 747                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 748                 {
 749                         uint32_t _flags_save_string = ndr->flags;
 750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 752                         if (_ptr_name) {
 753                                 NDR_PULL_ALLOC(ndr, r->name);
 754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 755                         } else {
 756                                 r->name = NULL;
 757                         }
 758                         ndr->flags = _flags_save_string;
 759                 }
 760                 {
 761                         uint32_t _flags_save_string = ndr->flags;
 762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 764                         if (_ptr_description) {
 765                                 NDR_PULL_ALLOC(ndr, r->description);
 766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 767                         } else {
 768                                 r->description = NULL;
 769                         }
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 776                         if (_ptr_comment) {
 777                                 NDR_PULL_ALLOC(ndr, r->comment);
 778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 779                         } else {
 780                                 r->comment = NULL;
 781                         }
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 uint32_t _relative_save_offset;
 791                                 _relative_save_offset = ndr->offset;
 792                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 793                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 795                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 796                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 797                                 ndr->offset = _relative_save_offset;
 798                         }
 799                         ndr->flags = _flags_save_string;
 800                 }
 801                 {
 802                         uint32_t _flags_save_string = ndr->flags;
 803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 804                         if (r->description) {
 805                                 uint32_t _relative_save_offset;
 806                                 _relative_save_offset = ndr->offset;
 807                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 808                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 809                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 810                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 811                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 812                                 ndr->offset = _relative_save_offset;
 813                         }
 814                         ndr->flags = _flags_save_string;
 815                 }
 816                 {
 817                         uint32_t _flags_save_string = ndr->flags;
 818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 819                         if (r->comment) {
 820                                 uint32_t _relative_save_offset;
 821                                 _relative_save_offset = ndr->offset;
 822                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 823                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 824                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 825                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 827                                 ndr->offset = _relative_save_offset;
 828                         }
 829                         ndr->flags = _flags_save_string;
 830                 }
 831         }
 832         return NDR_ERR_SUCCESS;
 833 }
 834
 835 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 836 {
 837         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 838         ndr->depth++;
 839         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 840         ndr_print_ptr(ndr, "name", r->name);
 841         ndr->depth++;
 842         if (r->name) {
 843                 ndr_print_string(ndr, "name", r->name);
 844         }
 845         ndr->depth--;
 846         ndr_print_ptr(ndr, "description", r->description);
 847         ndr->depth++;
 848         if (r->description) {
 849                 ndr_print_string(ndr, "description", r->description);
 850         }
 851         ndr->depth--;
 852         ndr_print_ptr(ndr, "comment", r->comment);
 853         ndr->depth++;
 854         if (r->comment) {
 855                 ndr_print_string(ndr, "comment", r->comment);
 856         }
 857         ndr->depth--;
 858         ndr->depth--;
 859 }
 860
 861 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 862 {
 863         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 868 {
 869         uint32_t v;
 870         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 871         *r = v;
 872         return NDR_ERR_SUCCESS;
 873 }
 874
 875 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 876 {
 877         ndr_print_uint32(ndr, name, r);
 878         ndr->depth++;
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 889         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 890         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 891         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 893         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 895         ndr->depth--;
 896 }
 897
 898 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 899 {
 900         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 901         return NDR_ERR_SUCCESS;
 902 }
 903
 904 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 905 {
 906         uint32_t v;
 907         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 908         *r = v;
 909         return NDR_ERR_SUCCESS;
 910 }
 911
 912 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 913 {
 914         ndr_print_uint32(ndr, name, r);
 915         ndr->depth++;
 916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 941         ndr->depth--;
 942 }
 943
 944 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 945 {
 946         if (ndr_flags & NDR_SCALARS) {
 947                 NDR_CHECK(ndr_push_align(ndr, 4));
 948                 {
 949                         uint32_t _flags_save_string = ndr->flags;
 950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 951                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 952                         ndr->flags = _flags_save_string;
 953                 }
 954                 {
 955                         uint32_t _flags_save_string = ndr->flags;
 956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 958                         ndr->flags = _flags_save_string;
 959                 }
 960                 {
 961                         uint32_t _flags_save_string = ndr->flags;
 962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 964                         ndr->flags = _flags_save_string;
 965                 }
 966                 {
 967                         uint32_t _flags_save_string = ndr->flags;
 968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
 970                         ndr->flags = _flags_save_string;
 971                 }
 972                 {
 973                         uint32_t _flags_save_string = ndr->flags;
 974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
 976                         ndr->flags = _flags_save_string;
 977                 }
 978                 {
 979                         uint32_t _flags_save_string = ndr->flags;
 980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 982                         ndr->flags = _flags_save_string;
 983                 }
 984                 {
 985                         uint32_t _flags_save_string = ndr->flags;
 986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
 988                         ndr->flags = _flags_save_string;
 989                 }
 990                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
 991                 {
 992                         uint32_t _flags_save_string = ndr->flags;
 993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 994                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
 995                         ndr->flags = _flags_save_string;
 996                 }
 997                 {
 998                         uint32_t _flags_save_string = ndr->flags;
 999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1000                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1001                         ndr->flags = _flags_save_string;
1002                 }
1003                 {
1004                         uint32_t _flags_save_string = ndr->flags;
1005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1007                         ndr->flags = _flags_save_string;
1008                 }
1009                 {
1010                         uint32_t _flags_save_string = ndr->flags;
1011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1013                         ndr->flags = _flags_save_string;
1014                 }
1015                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1016                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1021                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1024         }
1025         if (ndr_flags & NDR_BUFFERS) {
1026                 {
1027                         uint32_t _flags_save_string = ndr->flags;
1028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1029                         if (r->servername) {
1030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1032                         }
1033                         ndr->flags = _flags_save_string;
1034                 }
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         if (r->printername) {
1039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1041                         }
1042                         ndr->flags = _flags_save_string;
1043                 }
1044                 {
1045                         uint32_t _flags_save_string = ndr->flags;
1046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1047                         if (r->sharename) {
1048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1050                         }
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         if (r->portname) {
1057                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1058                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1059                         }
1060                         ndr->flags = _flags_save_string;
1061                 }
1062                 {
1063                         uint32_t _flags_save_string = ndr->flags;
1064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1065                         if (r->drivername) {
1066                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1067                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1068                         }
1069                         ndr->flags = _flags_save_string;
1070                 }
1071                 {
1072                         uint32_t _flags_save_string = ndr->flags;
1073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1074                         if (r->comment) {
1075                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1076                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1077                         }
1078                         ndr->flags = _flags_save_string;
1079                 }
1080                 {
1081                         uint32_t _flags_save_string = ndr->flags;
1082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1083                         if (r->location) {
1084                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1085                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1086                         }
1087                         ndr->flags = _flags_save_string;
1088                 }
1089                 if (r->devmode) {
1090                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1091                         {
1092                                 struct ndr_push *_ndr_devmode;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1094                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1096                         }
1097                 }
1098                 {
1099                         uint32_t _flags_save_string = ndr->flags;
1100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1101                         if (r->sepfile) {
1102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1104                         }
1105                         ndr->flags = _flags_save_string;
1106                 }
1107                 {
1108                         uint32_t _flags_save_string = ndr->flags;
1109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1110                         if (r->printprocessor) {
1111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1113                         }
1114                         ndr->flags = _flags_save_string;
1115                 }
1116                 {
1117                         uint32_t _flags_save_string = ndr->flags;
1118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1119                         if (r->datatype) {
1120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1122                         }
1123                         ndr->flags = _flags_save_string;
1124                 }
1125                 {
1126                         uint32_t _flags_save_string = ndr->flags;
1127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1128                         if (r->parameters) {
1129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1131                         }
1132                         ndr->flags = _flags_save_string;
1133                 }
1134                 if (r->secdesc) {
1135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1136                         {
1137                                 struct ndr_push *_ndr_secdesc;
1138                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1139                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1140                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1141                         }
1142                 }
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1148 {
1149         uint32_t _ptr_servername;
1150         TALLOC_CTX *_mem_save_servername_0;
1151         uint32_t _ptr_printername;
1152         TALLOC_CTX *_mem_save_printername_0;
1153         uint32_t _ptr_sharename;
1154         TALLOC_CTX *_mem_save_sharename_0;
1155         uint32_t _ptr_portname;
1156         TALLOC_CTX *_mem_save_portname_0;
1157         uint32_t _ptr_drivername;
1158         TALLOC_CTX *_mem_save_drivername_0;
1159         uint32_t _ptr_comment;
1160         TALLOC_CTX *_mem_save_comment_0;
1161         uint32_t _ptr_location;
1162         TALLOC_CTX *_mem_save_location_0;
1163         uint32_t _ptr_devmode;
1164         TALLOC_CTX *_mem_save_devmode_0;
1165         uint32_t _ptr_sepfile;
1166         TALLOC_CTX *_mem_save_sepfile_0;
1167         uint32_t _ptr_printprocessor;
1168         TALLOC_CTX *_mem_save_printprocessor_0;
1169         uint32_t _ptr_datatype;
1170         TALLOC_CTX *_mem_save_datatype_0;
1171         uint32_t _ptr_parameters;
1172         TALLOC_CTX *_mem_save_parameters_0;
1173         uint32_t _ptr_secdesc;
1174         TALLOC_CTX *_mem_save_secdesc_0;
1175         if (ndr_flags & NDR_SCALARS) {
1176                 NDR_CHECK(ndr_pull_align(ndr, 4));
1177                 {
1178                         uint32_t _flags_save_string = ndr->flags;
1179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1181                         if (_ptr_servername) {
1182                                 NDR_PULL_ALLOC(ndr, r->servername);
1183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1184                         } else {
1185                                 r->servername = NULL;
1186                         }
1187                         ndr->flags = _flags_save_string;
1188                 }
1189                 {
1190                         uint32_t _flags_save_string = ndr->flags;
1191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1193                         if (_ptr_printername) {
1194                                 NDR_PULL_ALLOC(ndr, r->printername);
1195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1196                         } else {
1197                                 r->printername = NULL;
1198                         }
1199                         ndr->flags = _flags_save_string;
1200                 }
1201                 {
1202                         uint32_t _flags_save_string = ndr->flags;
1203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1205                         if (_ptr_sharename) {
1206                                 NDR_PULL_ALLOC(ndr, r->sharename);
1207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1208                         } else {
1209                                 r->sharename = NULL;
1210                         }
1211                         ndr->flags = _flags_save_string;
1212                 }
1213                 {
1214                         uint32_t _flags_save_string = ndr->flags;
1215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1217                         if (_ptr_portname) {
1218                                 NDR_PULL_ALLOC(ndr, r->portname);
1219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1220                         } else {
1221                                 r->portname = NULL;
1222                         }
1223                         ndr->flags = _flags_save_string;
1224                 }
1225                 {
1226                         uint32_t _flags_save_string = ndr->flags;
1227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1229                         if (_ptr_drivername) {
1230                                 NDR_PULL_ALLOC(ndr, r->drivername);
1231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1232                         } else {
1233                                 r->drivername = NULL;
1234                         }
1235                         ndr->flags = _flags_save_string;
1236                 }
1237                 {
1238                         uint32_t _flags_save_string = ndr->flags;
1239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1241                         if (_ptr_comment) {
1242                                 NDR_PULL_ALLOC(ndr, r->comment);
1243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1244                         } else {
1245                                 r->comment = NULL;
1246                         }
1247                         ndr->flags = _flags_save_string;
1248                 }
1249                 {
1250                         uint32_t _flags_save_string = ndr->flags;
1251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1253                         if (_ptr_location) {
1254                                 NDR_PULL_ALLOC(ndr, r->location);
1255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1256                         } else {
1257                                 r->location = NULL;
1258                         }
1259                         ndr->flags = _flags_save_string;
1260                 }
1261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1262                 if (_ptr_devmode) {
1263                         NDR_PULL_ALLOC(ndr, r->devmode);
1264                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1265                 } else {
1266                         r->devmode = NULL;
1267                 }
1268                 {
1269                         uint32_t _flags_save_string = ndr->flags;
1270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1272                         if (_ptr_sepfile) {
1273                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1275                         } else {
1276                                 r->sepfile = NULL;
1277                         }
1278                         ndr->flags = _flags_save_string;
1279                 }
1280                 {
1281                         uint32_t _flags_save_string = ndr->flags;
1282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1284                         if (_ptr_printprocessor) {
1285                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1287                         } else {
1288                                 r->printprocessor = NULL;
1289                         }
1290                         ndr->flags = _flags_save_string;
1291                 }
1292                 {
1293                         uint32_t _flags_save_string = ndr->flags;
1294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1296                         if (_ptr_datatype) {
1297                                 NDR_PULL_ALLOC(ndr, r->datatype);
1298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1299                         } else {
1300                                 r->datatype = NULL;
1301                         }
1302                         ndr->flags = _flags_save_string;
1303                 }
1304                 {
1305                         uint32_t _flags_save_string = ndr->flags;
1306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1307                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1308                         if (_ptr_parameters) {
1309                                 NDR_PULL_ALLOC(ndr, r->parameters);
1310                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1311                         } else {
1312                                 r->parameters = NULL;
1313                         }
1314                         ndr->flags = _flags_save_string;
1315                 }
1316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1317                 if (_ptr_secdesc) {
1318                         NDR_PULL_ALLOC(ndr, r->secdesc);
1319                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1320                 } else {
1321                         r->secdesc = NULL;
1322                 }
1323                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1328                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1331         }
1332         if (ndr_flags & NDR_BUFFERS) {
1333                 {
1334                         uint32_t _flags_save_string = ndr->flags;
1335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1336                         if (r->servername) {
1337                                 uint32_t _relative_save_offset;
1338                                 _relative_save_offset = ndr->offset;
1339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1340                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1341                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1344                                 ndr->offset = _relative_save_offset;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         if (r->printername) {
1352                                 uint32_t _relative_save_offset;
1353                                 _relative_save_offset = ndr->offset;
1354                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1355                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1356                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1357                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1358                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1359                                 ndr->offset = _relative_save_offset;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 {
1364                         uint32_t _flags_save_string = ndr->flags;
1365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1366                         if (r->sharename) {
1367                                 uint32_t _relative_save_offset;
1368                                 _relative_save_offset = ndr->offset;
1369                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1370                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1371                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1372                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1373                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1374                                 ndr->offset = _relative_save_offset;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         if (r->portname) {
1382                                 uint32_t _relative_save_offset;
1383                                 _relative_save_offset = ndr->offset;
1384                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1385                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1386                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1387                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1388                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1389                                 ndr->offset = _relative_save_offset;
1390                         }
1391                         ndr->flags = _flags_save_string;
1392                 }
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->drivername) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1400                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1404                                 ndr->offset = _relative_save_offset;
1405                         }
1406                         ndr->flags = _flags_save_string;
1407                 }
1408                 {
1409                         uint32_t _flags_save_string = ndr->flags;
1410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1411                         if (r->comment) {
1412                                 uint32_t _relative_save_offset;
1413                                 _relative_save_offset = ndr->offset;
1414                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1415                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1416                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1417                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1418                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1419                                 ndr->offset = _relative_save_offset;
1420                         }
1421                         ndr->flags = _flags_save_string;
1422                 }
1423                 {
1424                         uint32_t _flags_save_string = ndr->flags;
1425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1426                         if (r->location) {
1427                                 uint32_t _relative_save_offset;
1428                                 _relative_save_offset = ndr->offset;
1429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1430                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1431                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1434                                 ndr->offset = _relative_save_offset;
1435                         }
1436                         ndr->flags = _flags_save_string;
1437                 }
1438                 if (r->devmode) {
1439                         uint32_t _relative_save_offset;
1440                         _relative_save_offset = ndr->offset;
1441                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1442                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1443                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1444                         {
1445                                 struct ndr_pull *_ndr_devmode;
1446                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1447                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1448                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1449                         }
1450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1451                         ndr->offset = _relative_save_offset;
1452                 }
1453                 {
1454                         uint32_t _flags_save_string = ndr->flags;
1455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1456                         if (r->sepfile) {
1457                                 uint32_t _relative_save_offset;
1458                                 _relative_save_offset = ndr->offset;
1459                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1460                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1461                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1462                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1463                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1464                                 ndr->offset = _relative_save_offset;
1465                         }
1466                         ndr->flags = _flags_save_string;
1467                 }
1468                 {
1469                         uint32_t _flags_save_string = ndr->flags;
1470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1471                         if (r->printprocessor) {
1472                                 uint32_t _relative_save_offset;
1473                                 _relative_save_offset = ndr->offset;
1474                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1475                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1476                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1477                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1478                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1479                                 ndr->offset = _relative_save_offset;
1480                         }
1481                         ndr->flags = _flags_save_string;
1482                 }
1483                 {
1484                         uint32_t _flags_save_string = ndr->flags;
1485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1486                         if (r->datatype) {
1487                                 uint32_t _relative_save_offset;
1488                                 _relative_save_offset = ndr->offset;
1489                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1490                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1491                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1492                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1493                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1494                                 ndr->offset = _relative_save_offset;
1495                         }
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         if (r->parameters) {
1502                                 uint32_t _relative_save_offset;
1503                                 _relative_save_offset = ndr->offset;
1504                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1505                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1506                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1507                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1508                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1509                                 ndr->offset = _relative_save_offset;
1510                         }
1511                         ndr->flags = _flags_save_string;
1512                 }
1513                 if (r->secdesc) {
1514                         uint32_t _relative_save_offset;
1515                         _relative_save_offset = ndr->offset;
1516                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1517                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1518                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1519                         {
1520                                 struct ndr_pull *_ndr_secdesc;
1521                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1522                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1523                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1524                         }
1525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1526                         ndr->offset = _relative_save_offset;
1527                 }
1528         }
1529         return NDR_ERR_SUCCESS;
1530 }
1531
1532 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1533 {
1534         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1535         ndr->depth++;
1536         ndr_print_ptr(ndr, "servername", r->servername);
1537         ndr->depth++;
1538         if (r->servername) {
1539                 ndr_print_string(ndr, "servername", r->servername);
1540         }
1541         ndr->depth--;
1542         ndr_print_ptr(ndr, "printername", r->printername);
1543         ndr->depth++;
1544         if (r->printername) {
1545                 ndr_print_string(ndr, "printername", r->printername);
1546         }
1547         ndr->depth--;
1548         ndr_print_ptr(ndr, "sharename", r->sharename);
1549         ndr->depth++;
1550         if (r->sharename) {
1551                 ndr_print_string(ndr, "sharename", r->sharename);
1552         }
1553         ndr->depth--;
1554         ndr_print_ptr(ndr, "portname", r->portname);
1555         ndr->depth++;
1556         if (r->portname) {
1557                 ndr_print_string(ndr, "portname", r->portname);
1558         }
1559         ndr->depth--;
1560         ndr_print_ptr(ndr, "drivername", r->drivername);
1561         ndr->depth++;
1562         if (r->drivername) {
1563                 ndr_print_string(ndr, "drivername", r->drivername);
1564         }
1565         ndr->depth--;
1566         ndr_print_ptr(ndr, "comment", r->comment);
1567         ndr->depth++;
1568         if (r->comment) {
1569                 ndr_print_string(ndr, "comment", r->comment);
1570         }
1571         ndr->depth--;
1572         ndr_print_ptr(ndr, "location", r->location);
1573         ndr->depth++;
1574         if (r->location) {
1575                 ndr_print_string(ndr, "location", r->location);
1576         }
1577         ndr->depth--;
1578         ndr_print_ptr(ndr, "devmode", r->devmode);
1579         ndr->depth++;
1580         if (r->devmode) {
1581                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1582         }
1583         ndr->depth--;
1584         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1585         ndr->depth++;
1586         if (r->sepfile) {
1587                 ndr_print_string(ndr, "sepfile", r->sepfile);
1588         }
1589         ndr->depth--;
1590         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1591         ndr->depth++;
1592         if (r->printprocessor) {
1593                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1594         }
1595         ndr->depth--;
1596         ndr_print_ptr(ndr, "datatype", r->datatype);
1597         ndr->depth++;
1598         if (r->datatype) {
1599                 ndr_print_string(ndr, "datatype", r->datatype);
1600         }
1601         ndr->depth--;
1602         ndr_print_ptr(ndr, "parameters", r->parameters);
1603         ndr->depth++;
1604         if (r->parameters) {
1605                 ndr_print_string(ndr, "parameters", r->parameters);
1606         }
1607         ndr->depth--;
1608         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1609         ndr->depth++;
1610         if (r->secdesc) {
1611                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1612         }
1613         ndr->depth--;
1614         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1615         ndr_print_uint32(ndr, "priority", r->priority);
1616         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1617         ndr_print_uint32(ndr, "starttime", r->starttime);
1618         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1619         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1620         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1621         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1622         ndr->depth--;
1623 }
1624
1625 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1626 {
1627         if (ndr_flags & NDR_SCALARS) {
1628                 NDR_CHECK(ndr_push_align(ndr, 4));
1629                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1630         }
1631         if (ndr_flags & NDR_BUFFERS) {
1632                 if (r->secdesc) {
1633                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1634                         {
1635                                 struct ndr_push *_ndr_secdesc;
1636                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1637                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1638                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1639                         }
1640                 }
1641         }
1642         return NDR_ERR_SUCCESS;
1643 }
1644
1645 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1646 {
1647         uint32_t _ptr_secdesc;
1648         TALLOC_CTX *_mem_save_secdesc_0;
1649         if (ndr_flags & NDR_SCALARS) {
1650                 NDR_CHECK(ndr_pull_align(ndr, 4));
1651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1652                 if (_ptr_secdesc) {
1653                         NDR_PULL_ALLOC(ndr, r->secdesc);
1654                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1655                 } else {
1656                         r->secdesc = NULL;
1657                 }
1658         }
1659         if (ndr_flags & NDR_BUFFERS) {
1660                 if (r->secdesc) {
1661                         uint32_t _relative_save_offset;
1662                         _relative_save_offset = ndr->offset;
1663                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1664                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1665                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1666                         {
1667                                 struct ndr_pull *_ndr_secdesc;
1668                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1669                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1670                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1671                         }
1672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1673                         ndr->offset = _relative_save_offset;
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1680 {
1681         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1682         ndr->depth++;
1683         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1684         ndr->depth++;
1685         if (r->secdesc) {
1686                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1687         }
1688         ndr->depth--;
1689         ndr->depth--;
1690 }
1691
1692 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1693 {
1694         if (ndr_flags & NDR_SCALARS) {
1695                 NDR_CHECK(ndr_push_align(ndr, 4));
1696                 {
1697                         uint32_t _flags_save_string = ndr->flags;
1698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1700                         ndr->flags = _flags_save_string;
1701                 }
1702                 {
1703                         uint32_t _flags_save_string = ndr->flags;
1704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1705                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1706                         ndr->flags = _flags_save_string;
1707                 }
1708                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1709         }
1710         if (ndr_flags & NDR_BUFFERS) {
1711                 {
1712                         uint32_t _flags_save_string = ndr->flags;
1713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1714                         if (r->printername) {
1715                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1716                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1717                         }
1718                         ndr->flags = _flags_save_string;
1719                 }
1720                 {
1721                         uint32_t _flags_save_string = ndr->flags;
1722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1723                         if (r->servername) {
1724                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1725                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1726                         }
1727                         ndr->flags = _flags_save_string;
1728                 }
1729         }
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1734 {
1735         uint32_t _ptr_printername;
1736         TALLOC_CTX *_mem_save_printername_0;
1737         uint32_t _ptr_servername;
1738         TALLOC_CTX *_mem_save_servername_0;
1739         if (ndr_flags & NDR_SCALARS) {
1740                 NDR_CHECK(ndr_pull_align(ndr, 4));
1741                 {
1742                         uint32_t _flags_save_string = ndr->flags;
1743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1745                         if (_ptr_printername) {
1746                                 NDR_PULL_ALLOC(ndr, r->printername);
1747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1748                         } else {
1749                                 r->printername = NULL;
1750                         }
1751                         ndr->flags = _flags_save_string;
1752                 }
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1757                         if (_ptr_servername) {
1758                                 NDR_PULL_ALLOC(ndr, r->servername);
1759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1760                         } else {
1761                                 r->servername = NULL;
1762                         }
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 uint32_t _relative_save_offset;
1773                                 _relative_save_offset = ndr->offset;
1774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1775                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1776                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1779                                 ndr->offset = _relative_save_offset;
1780                         }
1781                         ndr->flags = _flags_save_string;
1782                 }
1783                 {
1784                         uint32_t _flags_save_string = ndr->flags;
1785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1786                         if (r->servername) {
1787                                 uint32_t _relative_save_offset;
1788                                 _relative_save_offset = ndr->offset;
1789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1790                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1791                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1794                                 ndr->offset = _relative_save_offset;
1795                         }
1796                         ndr->flags = _flags_save_string;
1797                 }
1798         }
1799         return NDR_ERR_SUCCESS;
1800 }
1801
1802 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1803 {
1804         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1805         ndr->depth++;
1806         ndr_print_ptr(ndr, "printername", r->printername);
1807         ndr->depth++;
1808         if (r->printername) {
1809                 ndr_print_string(ndr, "printername", r->printername);
1810         }
1811         ndr->depth--;
1812         ndr_print_ptr(ndr, "servername", r->servername);
1813         ndr->depth++;
1814         if (r->servername) {
1815                 ndr_print_string(ndr, "servername", r->servername);
1816         }
1817         ndr->depth--;
1818         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1819         ndr->depth--;
1820 }
1821
1822 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1823 {
1824         if (ndr_flags & NDR_SCALARS) {
1825                 NDR_CHECK(ndr_push_align(ndr, 4));
1826                 {
1827                         uint32_t _flags_save_string = ndr->flags;
1828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1830                         ndr->flags = _flags_save_string;
1831                 }
1832                 {
1833                         uint32_t _flags_save_string = ndr->flags;
1834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1841         }
1842         if (ndr_flags & NDR_BUFFERS) {
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         if (r->printername) {
1847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1848                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1849                         }
1850                         ndr->flags = _flags_save_string;
1851                 }
1852                 {
1853                         uint32_t _flags_save_string = ndr->flags;
1854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1855                         if (r->portname) {
1856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1858                         }
1859                         ndr->flags = _flags_save_string;
1860                 }
1861         }
1862         return NDR_ERR_SUCCESS;
1863 }
1864
1865 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1866 {
1867         uint32_t _ptr_printername;
1868         TALLOC_CTX *_mem_save_printername_0;
1869         uint32_t _ptr_portname;
1870         TALLOC_CTX *_mem_save_portname_0;
1871         if (ndr_flags & NDR_SCALARS) {
1872                 NDR_CHECK(ndr_pull_align(ndr, 4));
1873                 {
1874                         uint32_t _flags_save_string = ndr->flags;
1875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1877                         if (_ptr_printername) {
1878                                 NDR_PULL_ALLOC(ndr, r->printername);
1879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1880                         } else {
1881                                 r->printername = NULL;
1882                         }
1883                         ndr->flags = _flags_save_string;
1884                 }
1885                 {
1886                         uint32_t _flags_save_string = ndr->flags;
1887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1889                         if (_ptr_portname) {
1890                                 NDR_PULL_ALLOC(ndr, r->portname);
1891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1892                         } else {
1893                                 r->portname = NULL;
1894                         }
1895                         ndr->flags = _flags_save_string;
1896                 }
1897                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 {
1903                         uint32_t _flags_save_string = ndr->flags;
1904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1905                         if (r->printername) {
1906                                 uint32_t _relative_save_offset;
1907                                 _relative_save_offset = ndr->offset;
1908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1909                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1910                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1913                                 ndr->offset = _relative_save_offset;
1914                         }
1915                         ndr->flags = _flags_save_string;
1916                 }
1917                 {
1918                         uint32_t _flags_save_string = ndr->flags;
1919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1920                         if (r->portname) {
1921                                 uint32_t _relative_save_offset;
1922                                 _relative_save_offset = ndr->offset;
1923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1924                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1925                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1928                                 ndr->offset = _relative_save_offset;
1929                         }
1930                         ndr->flags = _flags_save_string;
1931                 }
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1937 {
1938         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1939         ndr->depth++;
1940         ndr_print_ptr(ndr, "printername", r->printername);
1941         ndr->depth++;
1942         if (r->printername) {
1943                 ndr_print_string(ndr, "printername", r->printername);
1944         }
1945         ndr->depth--;
1946         ndr_print_ptr(ndr, "portname", r->portname);
1947         ndr->depth++;
1948         if (r->portname) {
1949                 ndr_print_string(ndr, "portname", r->portname);
1950         }
1951         ndr->depth--;
1952         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1953         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1954         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1955         ndr->depth--;
1956 }
1957
1958 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1959 {
1960         if (ndr_flags & NDR_SCALARS) {
1961                 NDR_CHECK(ndr_push_align(ndr, 4));
1962                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1963         }
1964         if (ndr_flags & NDR_BUFFERS) {
1965         }
1966         return NDR_ERR_SUCCESS;
1967 }
1968
1969 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
1970 {
1971         if (ndr_flags & NDR_SCALARS) {
1972                 NDR_CHECK(ndr_pull_align(ndr, 4));
1973                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976         }
1977         return NDR_ERR_SUCCESS;
1978 }
1979
1980 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
1981 {
1982         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
1983         ndr->depth++;
1984         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1985         ndr->depth--;
1986 }
1987
1988 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1989 {
1990         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1991         return NDR_ERR_SUCCESS;
1992 }
1993
1994 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1995 {
1996         uint32_t v;
1997         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1998         *r = v;
1999         return NDR_ERR_SUCCESS;
2000 }
2001
2002 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2003 {
2004         ndr_print_uint32(ndr, name, r);
2005         ndr->depth++;
2006         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2007         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2008         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2009         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2010         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2011         ndr->depth--;
2012 }
2013
2014 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2015 {
2016         if (ndr_flags & NDR_SCALARS) {
2017                 NDR_CHECK(ndr_push_align(ndr, 4));
2018                 {
2019                         uint32_t _flags_save_string = ndr->flags;
2020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2022                         ndr->flags = _flags_save_string;
2023                 }
2024                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2025         }
2026         if (ndr_flags & NDR_BUFFERS) {
2027                 {
2028                         uint32_t _flags_save_string = ndr->flags;
2029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2030                         if (r->guid) {
2031                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2032                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2033                         }
2034                         ndr->flags = _flags_save_string;
2035                 }
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2041 {
2042         uint32_t _ptr_guid;
2043         TALLOC_CTX *_mem_save_guid_0;
2044         if (ndr_flags & NDR_SCALARS) {
2045                 NDR_CHECK(ndr_pull_align(ndr, 4));
2046                 {
2047                         uint32_t _flags_save_string = ndr->flags;
2048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2050                         if (_ptr_guid) {
2051                                 NDR_PULL_ALLOC(ndr, r->guid);
2052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2053                         } else {
2054                                 r->guid = NULL;
2055                         }
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 uint32_t _relative_save_offset;
2066                                 _relative_save_offset = ndr->offset;
2067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2068                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2069                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2072                                 ndr->offset = _relative_save_offset;
2073                         }
2074                         ndr->flags = _flags_save_string;
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2081 {
2082         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2083         ndr->depth++;
2084         ndr_print_ptr(ndr, "guid", r->guid);
2085         ndr->depth++;
2086         if (r->guid) {
2087                 ndr_print_string(ndr, "guid", r->guid);
2088         }
2089         ndr->depth--;
2090         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2091         ndr->depth--;
2092 }
2093
2094 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2095 {
2096         if (ndr_flags & NDR_SCALARS) {
2097                 NDR_CHECK(ndr_push_align(ndr, 4));
2098                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2099         }
2100         if (ndr_flags & NDR_BUFFERS) {
2101                 if (r->devmode) {
2102                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2103                         {
2104                                 struct ndr_push *_ndr_devmode;
2105                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2106                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2107                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2108                         }
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2115 {
2116         uint32_t _ptr_devmode;
2117         TALLOC_CTX *_mem_save_devmode_0;
2118         if (ndr_flags & NDR_SCALARS) {
2119                 NDR_CHECK(ndr_pull_align(ndr, 4));
2120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2121                 if (_ptr_devmode) {
2122                         NDR_PULL_ALLOC(ndr, r->devmode);
2123                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2124                 } else {
2125                         r->devmode = NULL;
2126                 }
2127         }
2128         if (ndr_flags & NDR_BUFFERS) {
2129                 if (r->devmode) {
2130                         uint32_t _relative_save_offset;
2131                         _relative_save_offset = ndr->offset;
2132                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2133                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2134                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2135                         {
2136                                 struct ndr_pull *_ndr_devmode;
2137                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2138                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2139                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2140                         }
2141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2142                         ndr->offset = _relative_save_offset;
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2149 {
2150         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2151         ndr->depth++;
2152         ndr_print_ptr(ndr, "devmode", r->devmode);
2153         ndr->depth++;
2154         if (r->devmode) {
2155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2156         }
2157         ndr->depth--;
2158         ndr->depth--;
2159 }
2160
2161 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2162 {
2163         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2164         if (ndr_flags & NDR_SCALARS) {
2165                 int level = ndr_push_get_switch_value(ndr, r);
2166                 switch (level) {
2167                         case 0: {
2168                                 NDR_CHECK(ndr_push_align(ndr, 4));
2169                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2170                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2171                         break; }
2172
2173                         case 1: {
2174                                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2176                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2177                         break; }
2178
2179                         case 2: {
2180                                 NDR_CHECK(ndr_push_align(ndr, 4));
2181                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2182                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2183                         break; }
2184
2185                         case 3: {
2186                                 NDR_CHECK(ndr_push_align(ndr, 4));
2187                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2188                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2189                         break; }
2190
2191                         case 4: {
2192                                 NDR_CHECK(ndr_push_align(ndr, 4));
2193                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2194                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2195                         break; }
2196
2197                         case 5: {
2198                                 NDR_CHECK(ndr_push_align(ndr, 4));
2199                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2200                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2201                         break; }
2202
2203                         case 6: {
2204                                 NDR_CHECK(ndr_push_align(ndr, 4));
2205                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2206                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2207                         break; }
2208
2209                         case 7: {
2210                                 NDR_CHECK(ndr_push_align(ndr, 4));
2211                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2212                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2213                         break; }
2214
2215                         case 8: {
2216                                 NDR_CHECK(ndr_push_align(ndr, 4));
2217                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2218                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2219                         break; }
2220
2221                         case 9: {
2222                                 NDR_CHECK(ndr_push_align(ndr, 4));
2223                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2224                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2225                         break; }
2226
2227                         default: {
2228                         break; }
2229
2230                 }
2231         }
2232         if (ndr_flags & NDR_BUFFERS) {
2233                 int level = ndr_push_get_switch_value(ndr, r);
2234                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2235                 switch (level) {
2236                         case 0:
2237                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2238                         break;
2239
2240                         case 1:
2241                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2242                         break;
2243
2244                         case 2:
2245                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2246                         break;
2247
2248                         case 3:
2249                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2250                         break;
2251
2252                         case 4:
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2254                         break;
2255
2256                         case 5:
2257                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2258                         break;
2259
2260                         case 6:
2261                         break;
2262
2263                         case 7:
2264                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2265                         break;
2266
2267                         case 8:
2268                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2269                         break;
2270
2271                         case 9:
2272                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2273                         break;
2274
2275                         default:
2276                         break;
2277
2278                 }
2279         }
2280         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2281         return NDR_ERR_SUCCESS;
2282 }
2283
2284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2285 {
2286         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2287         int level;
2288         level = ndr_pull_get_switch_value(ndr, r);
2289         if (ndr_flags & NDR_SCALARS) {
2290                 switch (level) {
2291                         case 0: {
2292                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2293                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2294                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2295                         break; }
2296
2297                         case 1: {
2298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2300                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2301                         break; }
2302
2303                         case 2: {
2304                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2305                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2306                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2307                         break; }
2308
2309                         case 3: {
2310                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2311                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2312                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2313                         break; }
2314
2315                         case 4: {
2316                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2317                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2318                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2319                         break; }
2320
2321                         case 5: {
2322                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2323                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2324                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2325                         break; }
2326
2327                         case 6: {
2328                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2329                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2330                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2331                         break; }
2332
2333                         case 7: {
2334                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2335                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2336                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2337                         break; }
2338
2339                         case 8: {
2340                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2341                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2342                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2343                         break; }
2344
2345                         case 9: {
2346                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2347                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2348                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2349                         break; }
2350
2351                         default: {
2352                         break; }
2353
2354                 }
2355         }
2356         if (ndr_flags & NDR_BUFFERS) {
2357                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2358                 switch (level) {
2359                         case 0:
2360                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2361                         break;
2362
2363                         case 1:
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2365                         break;
2366
2367                         case 2:
2368                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2369                         break;
2370
2371                         case 3:
2372                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2373                         break;
2374
2375                         case 4:
2376                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2377                         break;
2378
2379                         case 5:
2380                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2381                         break;
2382
2383                         case 6:
2384                         break;
2385
2386                         case 7:
2387                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2388                         break;
2389
2390                         case 8:
2391                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2392                         break;
2393
2394                         case 9:
2395                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2396                         break;
2397
2398                         default:
2399                         break;
2400
2401                 }
2402         }
2403         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2408 {
2409         int level;
2410         level = ndr_print_get_switch_value(ndr, r);
2411         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2412         switch (level) {
2413                 case 0:
2414                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2415                 break;
2416
2417                 case 1:
2418                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2419                 break;
2420
2421                 case 2:
2422                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2423                 break;
2424
2425                 case 3:
2426                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2427                 break;
2428
2429                 case 4:
2430                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2431                 break;
2432
2433                 case 5:
2434                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2435                 break;
2436
2437                 case 6:
2438                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2439                 break;
2440
2441                 case 7:
2442                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2443                 break;
2444
2445                 case 8:
2446                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2447                 break;
2448
2449                 case 9:
2450                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2451                 break;
2452
2453                 default:
2454                 break;
2455
2456         }
2457 }
2458
2459 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2460 {
2461         if (ndr_flags & NDR_SCALARS) {
2462                 NDR_CHECK(ndr_push_align(ndr, 4));
2463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2465         }
2466         if (ndr_flags & NDR_BUFFERS) {
2467                 if (r->devmode) {
2468                         {
2469                                 struct ndr_push *_ndr_devmode;
2470                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2471                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2472                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2473                         }
2474                 }
2475         }
2476         return NDR_ERR_SUCCESS;
2477 }
2478
2479 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2480 {
2481         uint32_t _ptr_devmode;
2482         TALLOC_CTX *_mem_save_devmode_0;
2483         if (ndr_flags & NDR_SCALARS) {
2484                 NDR_CHECK(ndr_pull_align(ndr, 4));
2485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2487                 if (_ptr_devmode) {
2488                         NDR_PULL_ALLOC(ndr, r->devmode);
2489                 } else {
2490                         r->devmode = NULL;
2491                 }
2492         }
2493         if (ndr_flags & NDR_BUFFERS) {
2494                 if (r->devmode) {
2495                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2497                         {
2498                                 struct ndr_pull *_ndr_devmode;
2499                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2500                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2501                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2502                         }
2503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2504                 }
2505         }
2506         return NDR_ERR_SUCCESS;
2507 }
2508
2509 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2510 {
2511         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2512         ndr->depth++;
2513         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2514         ndr_print_ptr(ndr, "devmode", r->devmode);
2515         ndr->depth++;
2516         if (r->devmode) {
2517                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2518         }
2519         ndr->depth--;
2520         ndr->depth--;
2521 }
2522
2523 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2524 {
2525         if (ndr_flags & NDR_SCALARS) {
2526                 NDR_CHECK(ndr_push_align(ndr, 4));
2527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2528                 {
2529                         uint32_t _flags_save_string = ndr->flags;
2530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2532                         ndr->flags = _flags_save_string;
2533                 }
2534                 {
2535                         uint32_t _flags_save_string = ndr->flags;
2536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2538                         ndr->flags = _flags_save_string;
2539                 }
2540                 {
2541                         uint32_t _flags_save_string = ndr->flags;
2542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2544                         ndr->flags = _flags_save_string;
2545                 }
2546                 {
2547                         uint32_t _flags_save_string = ndr->flags;
2548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2550                         ndr->flags = _flags_save_string;
2551                 }
2552                 {
2553                         uint32_t _flags_save_string = ndr->flags;
2554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2556                         ndr->flags = _flags_save_string;
2557                 }
2558                 {
2559                         uint32_t _flags_save_string = ndr->flags;
2560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2562                         ndr->flags = _flags_save_string;
2563                 }
2564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
2565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2569                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2570         }
2571         if (ndr_flags & NDR_BUFFERS) {
2572                 {
2573                         uint32_t _flags_save_string = ndr->flags;
2574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2575                         if (r->printer_name) {
2576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2578                         }
2579                         ndr->flags = _flags_save_string;
2580                 }
2581                 {
2582                         uint32_t _flags_save_string = ndr->flags;
2583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2584                         if (r->server_name) {
2585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2587                         }
2588                         ndr->flags = _flags_save_string;
2589                 }
2590                 {
2591                         uint32_t _flags_save_string = ndr->flags;
2592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2593                         if (r->user_name) {
2594                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2596                         }
2597                         ndr->flags = _flags_save_string;
2598                 }
2599                 {
2600                         uint32_t _flags_save_string = ndr->flags;
2601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2602                         if (r->document_name) {
2603                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2605                         }
2606                         ndr->flags = _flags_save_string;
2607                 }
2608                 {
2609                         uint32_t _flags_save_string = ndr->flags;
2610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2611                         if (r->data_type) {
2612                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2613                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2614                         }
2615                         ndr->flags = _flags_save_string;
2616                 }
2617                 {
2618                         uint32_t _flags_save_string = ndr->flags;
2619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2620                         if (r->text_status) {
2621                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2622                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2623                         }
2624                         ndr->flags = _flags_save_string;
2625                 }
2626         }
2627         return NDR_ERR_SUCCESS;
2628 }
2629
2630 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2631 {
2632         uint32_t _ptr_printer_name;
2633         TALLOC_CTX *_mem_save_printer_name_0;
2634         uint32_t _ptr_server_name;
2635         TALLOC_CTX *_mem_save_server_name_0;
2636         uint32_t _ptr_user_name;
2637         TALLOC_CTX *_mem_save_user_name_0;
2638         uint32_t _ptr_document_name;
2639         TALLOC_CTX *_mem_save_document_name_0;
2640         uint32_t _ptr_data_type;
2641         TALLOC_CTX *_mem_save_data_type_0;
2642         uint32_t _ptr_text_status;
2643         TALLOC_CTX *_mem_save_text_status_0;
2644         if (ndr_flags & NDR_SCALARS) {
2645                 NDR_CHECK(ndr_pull_align(ndr, 4));
2646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2647                 {
2648                         uint32_t _flags_save_string = ndr->flags;
2649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2651                         if (_ptr_printer_name) {
2652                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2654                         } else {
2655                                 r->printer_name = NULL;
2656                         }
2657                         ndr->flags = _flags_save_string;
2658                 }
2659                 {
2660                         uint32_t _flags_save_string = ndr->flags;
2661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2663                         if (_ptr_server_name) {
2664                                 NDR_PULL_ALLOC(ndr, r->server_name);
2665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2666                         } else {
2667                                 r->server_name = NULL;
2668                         }
2669                         ndr->flags = _flags_save_string;
2670                 }
2671                 {
2672                         uint32_t _flags_save_string = ndr->flags;
2673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2675                         if (_ptr_user_name) {
2676                                 NDR_PULL_ALLOC(ndr, r->user_name);
2677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2678                         } else {
2679                                 r->user_name = NULL;
2680                         }
2681                         ndr->flags = _flags_save_string;
2682                 }
2683                 {
2684                         uint32_t _flags_save_string = ndr->flags;
2685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2687                         if (_ptr_document_name) {
2688                                 NDR_PULL_ALLOC(ndr, r->document_name);
2689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2690                         } else {
2691                                 r->document_name = NULL;
2692                         }
2693                         ndr->flags = _flags_save_string;
2694                 }
2695                 {
2696                         uint32_t _flags_save_string = ndr->flags;
2697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2699                         if (_ptr_data_type) {
2700                                 NDR_PULL_ALLOC(ndr, r->data_type);
2701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2702                         } else {
2703                                 r->data_type = NULL;
2704                         }
2705                         ndr->flags = _flags_save_string;
2706                 }
2707                 {
2708                         uint32_t _flags_save_string = ndr->flags;
2709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2710                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2711                         if (_ptr_text_status) {
2712                                 NDR_PULL_ALLOC(ndr, r->text_status);
2713                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2714                         } else {
2715                                 r->text_status = NULL;
2716                         }
2717                         ndr->flags = _flags_save_string;
2718                 }
2719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
2720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2724                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2725         }
2726         if (ndr_flags & NDR_BUFFERS) {
2727                 {
2728                         uint32_t _flags_save_string = ndr->flags;
2729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2730                         if (r->printer_name) {
2731                                 uint32_t _relative_save_offset;
2732                                 _relative_save_offset = ndr->offset;
2733                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2734                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2735                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2736                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2737                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2738                                 ndr->offset = _relative_save_offset;
2739                         }
2740                         ndr->flags = _flags_save_string;
2741                 }
2742                 {
2743                         uint32_t _flags_save_string = ndr->flags;
2744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2745                         if (r->server_name) {
2746                                 uint32_t _relative_save_offset;
2747                                 _relative_save_offset = ndr->offset;
2748                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2749                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2750                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2751                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2752                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2753                                 ndr->offset = _relative_save_offset;
2754                         }
2755                         ndr->flags = _flags_save_string;
2756                 }
2757                 {
2758                         uint32_t _flags_save_string = ndr->flags;
2759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2760                         if (r->user_name) {
2761                                 uint32_t _relative_save_offset;
2762                                 _relative_save_offset = ndr->offset;
2763                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2764                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2765                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2766                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2767                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2768                                 ndr->offset = _relative_save_offset;
2769                         }
2770                         ndr->flags = _flags_save_string;
2771                 }
2772                 {
2773                         uint32_t _flags_save_string = ndr->flags;
2774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2775                         if (r->document_name) {
2776                                 uint32_t _relative_save_offset;
2777                                 _relative_save_offset = ndr->offset;
2778                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2779                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2780                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2781                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2782                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2783                                 ndr->offset = _relative_save_offset;
2784                         }
2785                         ndr->flags = _flags_save_string;
2786                 }
2787                 {
2788                         uint32_t _flags_save_string = ndr->flags;
2789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2790                         if (r->data_type) {
2791                                 uint32_t _relative_save_offset;
2792                                 _relative_save_offset = ndr->offset;
2793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2794                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2795                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2798                                 ndr->offset = _relative_save_offset;
2799                         }
2800                         ndr->flags = _flags_save_string;
2801                 }
2802                 {
2803                         uint32_t _flags_save_string = ndr->flags;
2804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2805                         if (r->text_status) {
2806                                 uint32_t _relative_save_offset;
2807                                 _relative_save_offset = ndr->offset;
2808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2809                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2810                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2813                                 ndr->offset = _relative_save_offset;
2814                         }
2815                         ndr->flags = _flags_save_string;
2816                 }
2817         }
2818         return NDR_ERR_SUCCESS;
2819 }
2820
2821 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2822 {
2823         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2824         ndr->depth++;
2825         ndr_print_uint32(ndr, "job_id", r->job_id);
2826         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2827         ndr->depth++;
2828         if (r->printer_name) {
2829                 ndr_print_string(ndr, "printer_name", r->printer_name);
2830         }
2831         ndr->depth--;
2832         ndr_print_ptr(ndr, "server_name", r->server_name);
2833         ndr->depth++;
2834         if (r->server_name) {
2835                 ndr_print_string(ndr, "server_name", r->server_name);
2836         }
2837         ndr->depth--;
2838         ndr_print_ptr(ndr, "user_name", r->user_name);
2839         ndr->depth++;
2840         if (r->user_name) {
2841                 ndr_print_string(ndr, "user_name", r->user_name);
2842         }
2843         ndr->depth--;
2844         ndr_print_ptr(ndr, "document_name", r->document_name);
2845         ndr->depth++;
2846         if (r->document_name) {
2847                 ndr_print_string(ndr, "document_name", r->document_name);
2848         }
2849         ndr->depth--;
2850         ndr_print_ptr(ndr, "data_type", r->data_type);
2851         ndr->depth++;
2852         if (r->data_type) {
2853                 ndr_print_string(ndr, "data_type", r->data_type);
2854         }
2855         ndr->depth--;
2856         ndr_print_ptr(ndr, "text_status", r->text_status);
2857         ndr->depth++;
2858         if (r->text_status) {
2859                 ndr_print_string(ndr, "text_status", r->text_status);
2860         }
2861         ndr->depth--;
2862         ndr_print_uint32(ndr, "status", r->status);
2863         ndr_print_uint32(ndr, "priority", r->priority);
2864         ndr_print_uint32(ndr, "position", r->position);
2865         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2866         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2867         ndr_print_spoolss_Time(ndr, "time", &r->time);
2868         ndr->depth--;
2869 }
2870
2871 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
2872 {
2873         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2874         if (ndr_flags & NDR_SCALARS) {
2875                 int level = ndr_push_get_switch_value(ndr, r);
2876                 switch (level) {
2877                         case 1: {
2878                                 NDR_CHECK(ndr_push_align(ndr, 4));
2879                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2880                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2881                         break; }
2882
2883                         case 2: {
2884                         break; }
2885
2886                         case 3: {
2887                         break; }
2888
2889                         default: {
2890                         break; }
2891
2892                 }
2893         }
2894         if (ndr_flags & NDR_BUFFERS) {
2895                 int level = ndr_push_get_switch_value(ndr, r);
2896                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2897                 switch (level) {
2898                         case 1:
2899                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2900                         break;
2901
2902                         case 2:
2903                         break;
2904
2905                         case 3:
2906                         break;
2907
2908                         default:
2909                         break;
2910
2911                 }
2912         }
2913         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2914         return NDR_ERR_SUCCESS;
2915 }
2916
2917 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
2918 {
2919         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2920         int level;
2921         level = ndr_pull_get_switch_value(ndr, r);
2922         if (ndr_flags & NDR_SCALARS) {
2923                 switch (level) {
2924                         case 1: {
2925                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2926                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2927                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2928                         break; }
2929
2930                         case 2: {
2931                         break; }
2932
2933                         case 3: {
2934                         break; }
2935
2936                         default: {
2937                         break; }
2938
2939                 }
2940         }
2941         if (ndr_flags & NDR_BUFFERS) {
2942                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2943                 switch (level) {
2944                         case 1:
2945                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2946                         break;
2947
2948                         case 2:
2949                         break;
2950
2951                         case 3:
2952                         break;
2953
2954                         default:
2955                         break;
2956
2957                 }
2958         }
2959         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2960         return NDR_ERR_SUCCESS;
2961 }
2962
2963 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
2964 {
2965         int level;
2966         level = ndr_print_get_switch_value(ndr, r);
2967         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
2968         switch (level) {
2969                 case 1:
2970                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
2971                 break;
2972
2973                 case 2:
2974                 break;
2975
2976                 case 3:
2977                 break;
2978
2979                 default:
2980                 break;
2981
2982         }
2983 }
2984
2985 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
2986 {
2987         if (ndr_flags & NDR_SCALARS) {
2988                 NDR_CHECK(ndr_push_align(ndr, 4));
2989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2990                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
2991                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
2992         }
2993         if (ndr_flags & NDR_BUFFERS) {
2994                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
2995         }
2996         return NDR_ERR_SUCCESS;
2997 }
2998
2999 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
3000 {
3001         if (ndr_flags & NDR_SCALARS) {
3002                 NDR_CHECK(ndr_pull_align(ndr, 4));
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3004                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
3005                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
3009         }
3010         return NDR_ERR_SUCCESS;
3011 }
3012
3013 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
3014 {
3015         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
3016         ndr->depth++;
3017         ndr_print_uint32(ndr, "level", r->level);
3018         ndr_print_set_switch_value(ndr, &r->info, r->level);
3019         ndr_print_spoolss_JobInfo(ndr, "info", &r->info);
3020         ndr->depth--;
3021 }
3022
3023 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
3024 {
3025         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3026         return NDR_ERR_SUCCESS;
3027 }
3028
3029 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
3030 {
3031         uint32_t v;
3032         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3033         *r = v;
3034         return NDR_ERR_SUCCESS;
3035 }
3036
3037 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
3038 {
3039         const char *val = NULL;
3040
3041         switch (r) {
3042                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
3043                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
3044                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
3045                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
3046                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
3047                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
3048                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
3049         }
3050         ndr_print_enum(ndr, name, "ENUM", val, r);
3051 }
3052
3053 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
3054 {
3055         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3056         return NDR_ERR_SUCCESS;
3057 }
3058
3059 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
3060 {
3061         uint32_t v;
3062         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3063         *r = v;
3064         return NDR_ERR_SUCCESS;
3065 }
3066
3067 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
3068 {
3069         const char *val = NULL;
3070
3071         switch (r) {
3072                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
3073                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
3074                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
3075                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
3076                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
3077         }
3078         ndr_print_enum(ndr, name, "ENUM", val, r);
3079 }
3080
3081 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
3082 {
3083         if (ndr_flags & NDR_SCALARS) {
3084                 NDR_CHECK(ndr_push_align(ndr, 4));
3085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
3089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
3090                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
3092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
3094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
3095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
3096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
3097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
3098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
3099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
3100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
3101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
3102                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
3103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
3104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
3105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
3106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
3107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
3108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
3109                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
3110                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
3111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
3112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
3113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
3114         }
3115         if (ndr_flags & NDR_BUFFERS) {
3116                 if (r->servername) {
3117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3121                 }
3122                 if (r->printername) {
3123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
3133 {
3134         uint32_t _ptr_servername;
3135         TALLOC_CTX *_mem_save_servername_0;
3136         uint32_t _ptr_printername;
3137         TALLOC_CTX *_mem_save_printername_0;
3138         if (ndr_flags & NDR_SCALARS) {
3139                 NDR_CHECK(ndr_pull_align(ndr, 4));
3140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3141                 if (_ptr_servername) {
3142                         NDR_PULL_ALLOC(ndr, r->servername);
3143                 } else {
3144                         r->servername = NULL;
3145                 }
3146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3147                 if (_ptr_printername) {
3148                         NDR_PULL_ALLOC(ndr, r->printername);
3149                 } else {
3150                         r->printername = NULL;
3151                 }
3152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
3154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
3155                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
3157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
3159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
3160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
3161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
3162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
3163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
3164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
3165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
3166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
3167                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
3168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
3169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
3170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
3171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
3172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
3173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
3174                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
3175                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
3176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
3177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
3178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
3179         }
3180         if (ndr_flags & NDR_BUFFERS) {
3181                 if (r->servername) {
3182                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3183                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3186                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3187                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3188                         }
3189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3192                 }
3193                 if (r->printername) {
3194                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3195                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3198                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3200                         }
3201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3204                 }
3205         }
3206         return NDR_ERR_SUCCESS;
3207 }
3208
3209 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
3210 {
3211         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
3212         ndr->depth++;
3213         ndr_print_ptr(ndr, "servername", r->servername);
3214         ndr->depth++;
3215         if (r->servername) {
3216                 ndr_print_string(ndr, "servername", r->servername);
3217         }
3218         ndr->depth--;
3219         ndr_print_ptr(ndr, "printername", r->printername);
3220         ndr->depth++;
3221         if (r->printername) {
3222                 ndr_print_string(ndr, "printername", r->printername);
3223         }
3224         ndr->depth--;
3225         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3226         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
3227         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
3228         ndr_print_spoolss_Time(ndr, "time", &r->time);
3229         ndr_print_uint32(ndr, "global_counter", r->global_counter);
3230         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3231         ndr_print_uint32(ndr, "version", r->version);
3232         ndr_print_uint32(ndr, "free_build", r->free_build);
3233         ndr_print_uint32(ndr, "spooling", r->spooling);
3234         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
3235         ndr_print_uint32(ndr, "session_counter", r->session_counter);
3236         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
3237         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
3238         ndr_print_uint32(ndr, "job_error", r->job_error);
3239         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
3240         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
3241         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
3242         ndr_print_uint32(ndr, "change_id", r->change_id);
3243         ndr_print_WERROR(ndr, "last_error", r->last_error);
3244         ndr_print_uint32(ndr, "status", r->status);
3245         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
3246         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
3247         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
3248         ndr_print_uint16(ndr, "processor_level", r->processor_level);
3249         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
3250         ndr_print_uint32(ndr, "reserved2", r->reserved2);
3251         ndr_print_uint32(ndr, "reserved3", r->reserved3);
3252         ndr->depth--;
3253 }
3254
3255 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
3256 {
3257         if (ndr_flags & NDR_SCALARS) {
3258                 NDR_CHECK(ndr_push_align(ndr, 4));
3259                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
3260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
3262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3263         }
3264         if (ndr_flags & NDR_BUFFERS) {
3265                 if (r->name) {
3266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3270                 }
3271                 if (r->description) {
3272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3276                 }
3277                 if (r->comment) {
3278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3282                 }
3283         }
3284         return NDR_ERR_SUCCESS;
3285 }
3286
3287 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
3288 {
3289         uint32_t _ptr_name;
3290         TALLOC_CTX *_mem_save_name_0;
3291         uint32_t _ptr_description;
3292         TALLOC_CTX *_mem_save_description_0;
3293         uint32_t _ptr_comment;
3294         TALLOC_CTX *_mem_save_comment_0;
3295         if (ndr_flags & NDR_SCALARS) {
3296                 NDR_CHECK(ndr_pull_align(ndr, 4));
3297                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3299                 if (_ptr_name) {
3300                         NDR_PULL_ALLOC(ndr, r->name);
3301                 } else {
3302                         r->name = NULL;
3303                 }
3304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
3305                 if (_ptr_description) {
3306                         NDR_PULL_ALLOC(ndr, r->description);
3307                 } else {
3308                         r->description = NULL;
3309                 }
3310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3311                 if (_ptr_comment) {
3312                         NDR_PULL_ALLOC(ndr, r->comment);
3313                 } else {
3314                         r->comment = NULL;
3315                 }
3316         }
3317         if (ndr_flags & NDR_BUFFERS) {
3318                 if (r->name) {
3319                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3320                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3323                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3324                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3325                         }
3326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3329                 }
3330                 if (r->description) {
3331                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
3332                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
3333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
3334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
3335                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
3336                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
3337                         }
3338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
3339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
3340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
3341                 }
3342                 if (r->comment) {
3343                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3347                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3349                         }
3350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3353                 }
3354         }
3355         return NDR_ERR_SUCCESS;
3356 }
3357
3358 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
3359 {
3360         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
3361         ndr->depth++;
3362         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
3363         ndr_print_ptr(ndr, "name", r->name);
3364         ndr->depth++;
3365         if (r->name) {
3366                 ndr_print_string(ndr, "name", r->name);
3367         }
3368         ndr->depth--;
3369         ndr_print_ptr(ndr, "description", r->description);
3370         ndr->depth++;
3371         if (r->description) {
3372                 ndr_print_string(ndr, "description", r->description);
3373         }
3374         ndr->depth--;
3375         ndr_print_ptr(ndr, "comment", r->comment);
3376         ndr->depth++;
3377         if (r->comment) {
3378                 ndr_print_string(ndr, "comment", r->comment);
3379         }
3380         ndr->depth--;
3381         ndr->depth--;
3382 }
3383
3384 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
3385 {
3386         if (ndr_flags & NDR_SCALARS) {
3387                 NDR_CHECK(ndr_push_align(ndr, 4));
3388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
3391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
3392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
3393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
3395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
3397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
3398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
3399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
3400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3401                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
3404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
3405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
3406                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
3407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
3409         }
3410         if (ndr_flags & NDR_BUFFERS) {
3411                 if (r->servername) {
3412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3416                 }
3417                 if (r->printername) {
3418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3422                 }
3423                 if (r->sharename) {
3424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3428                 }
3429                 if (r->portname) {
3430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3434                 }
3435                 if (r->drivername) {
3436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3440                 }
3441                 if (r->comment) {
3442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3446                 }
3447                 if (r->location) {
3448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3452                 }
3453                 if (r->devmode) {
3454                         {
3455                                 struct ndr_push *_ndr_devmode;
3456                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3457                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3458                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3459                         }
3460                 }
3461                 if (r->sepfile) {
3462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3465                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3466                 }
3467                 if (r->printprocessor) {
3468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3472                 }
3473                 if (r->datatype) {
3474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3478                 }
3479                 if (r->parameters) {
3480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3484                 }
3485                 if (r->secdesc) {
3486                         {
3487                                 struct ndr_push *_ndr_secdesc;
3488                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3489                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3490                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3491                         }
3492                 }
3493         }
3494         return NDR_ERR_SUCCESS;
3495 }
3496
3497 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
3498 {
3499         uint32_t _ptr_servername;
3500         TALLOC_CTX *_mem_save_servername_0;
3501         uint32_t _ptr_printername;
3502         TALLOC_CTX *_mem_save_printername_0;
3503         uint32_t _ptr_sharename;
3504         TALLOC_CTX *_mem_save_sharename_0;
3505         uint32_t _ptr_portname;
3506         TALLOC_CTX *_mem_save_portname_0;
3507         uint32_t _ptr_drivername;
3508         TALLOC_CTX *_mem_save_drivername_0;
3509         uint32_t _ptr_comment;
3510         TALLOC_CTX *_mem_save_comment_0;
3511         uint32_t _ptr_location;
3512         TALLOC_CTX *_mem_save_location_0;
3513         uint32_t _ptr_devmode;
3514         TALLOC_CTX *_mem_save_devmode_0;
3515         uint32_t _ptr_sepfile;
3516         TALLOC_CTX *_mem_save_sepfile_0;
3517         uint32_t _ptr_printprocessor;
3518         TALLOC_CTX *_mem_save_printprocessor_0;
3519         uint32_t _ptr_datatype;
3520         TALLOC_CTX *_mem_save_datatype_0;
3521         uint32_t _ptr_parameters;
3522         TALLOC_CTX *_mem_save_parameters_0;
3523         uint32_t _ptr_secdesc;
3524         TALLOC_CTX *_mem_save_secdesc_0;
3525         if (ndr_flags & NDR_SCALARS) {
3526                 NDR_CHECK(ndr_pull_align(ndr, 4));
3527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3528                 if (_ptr_servername) {
3529                         NDR_PULL_ALLOC(ndr, r->servername);
3530                 } else {
3531                         r->servername = NULL;
3532                 }
3533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3534                 if (_ptr_printername) {
3535                         NDR_PULL_ALLOC(ndr, r->printername);
3536                 } else {
3537                         r->printername = NULL;
3538                 }
3539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3540                 if (_ptr_sharename) {
3541                         NDR_PULL_ALLOC(ndr, r->sharename);
3542                 } else {
3543                         r->sharename = NULL;
3544                 }
3545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
3546                 if (_ptr_portname) {
3547                         NDR_PULL_ALLOC(ndr, r->portname);
3548                 } else {
3549                         r->portname = NULL;
3550                 }
3551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
3552                 if (_ptr_drivername) {
3553                         NDR_PULL_ALLOC(ndr, r->drivername);
3554                 } else {
3555                         r->drivername = NULL;
3556                 }
3557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3558                 if (_ptr_comment) {
3559                         NDR_PULL_ALLOC(ndr, r->comment);
3560                 } else {
3561                         r->comment = NULL;
3562                 }
3563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
3564                 if (_ptr_location) {
3565                         NDR_PULL_ALLOC(ndr, r->location);
3566                 } else {
3567                         r->location = NULL;
3568                 }
3569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3570                 if (_ptr_devmode) {
3571                         NDR_PULL_ALLOC(ndr, r->devmode);
3572                 } else {
3573                         r->devmode = NULL;
3574                 }
3575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
3576                 if (_ptr_sepfile) {
3577                         NDR_PULL_ALLOC(ndr, r->sepfile);
3578                 } else {
3579                         r->sepfile = NULL;
3580                 }
3581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
3582                 if (_ptr_printprocessor) {
3583                         NDR_PULL_ALLOC(ndr, r->printprocessor);
3584                 } else {
3585                         r->printprocessor = NULL;
3586                 }
3587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
3588                 if (_ptr_datatype) {
3589                         NDR_PULL_ALLOC(ndr, r->datatype);
3590                 } else {
3591                         r->datatype = NULL;
3592                 }
3593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3594                 if (_ptr_parameters) {
3595                         NDR_PULL_ALLOC(ndr, r->parameters);
3596                 } else {
3597                         r->parameters = NULL;
3598                 }
3599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3600                 if (_ptr_secdesc) {
3601                         NDR_PULL_ALLOC(ndr, r->secdesc);
3602                 } else {
3603                         r->secdesc = NULL;
3604                 }
3605                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
3609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
3610                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
3611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
3613         }
3614         if (ndr_flags & NDR_BUFFERS) {
3615                 if (r->servername) {
3616                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3617                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3620                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3621                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3622                         }
3623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3626                 }
3627                 if (r->printername) {
3628                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3629                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3632                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3633                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3634                         }
3635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3638                 }
3639                 if (r->sharename) {
3640                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3641                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
3642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
3643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
3644                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
3645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
3646                         }
3647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
3648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
3649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3650                 }
3651                 if (r->portname) {
3652                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3653                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
3654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
3655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
3656                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
3657                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
3658                         }
3659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
3660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
3661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
3662                 }
3663                 if (r->drivername) {
3664                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3665                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
3666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
3667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
3668                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
3669                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
3670                         }
3671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
3672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
3673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
3674                 }
3675                 if (r->comment) {
3676                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3677                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3680                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3681                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3682                         }
3683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3686                 }
3687                 if (r->location) {
3688                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
3689                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
3690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
3691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
3692                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
3693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
3694                         }
3695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
3696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
3697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
3698                 }
3699                 if (r->devmode) {
3700                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3701                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3702                         {
3703                                 struct ndr_pull *_ndr_devmode;
3704                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3705                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3706                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3707                         }
3708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3709                 }
3710                 if (r->sepfile) {
3711                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
3712                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
3713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
3714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
3715                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
3716                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
3717                         }
3718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
3719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
3720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
3721                 }
3722                 if (r->printprocessor) {
3723                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3724                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
3725                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
3726                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
3727                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
3728                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
3729                         }
3730                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
3731                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
3732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
3733                 }
3734                 if (r->datatype) {
3735                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
3736                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
3737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
3738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
3739                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
3740                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
3741                         }
3742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
3743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
3744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
3745                 }
3746                 if (r->parameters) {
3747                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3748                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3749                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
3750                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
3751                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
3752                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
3753                         }
3754                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
3755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
3756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3757                 }
3758                 if (r->secdesc) {
3759                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3760                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3761                         {
3762                                 struct ndr_pull *_ndr_secdesc;
3763                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3764                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3765                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3766                         }
3767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3768                 }
3769         }
3770         return NDR_ERR_SUCCESS;
3771 }
3772
3773 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
3774 {
3775         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
3776         ndr->depth++;
3777         ndr_print_ptr(ndr, "servername", r->servername);
3778         ndr->depth++;
3779         if (r->servername) {
3780                 ndr_print_string(ndr, "servername", r->servername);
3781         }
3782         ndr->depth--;
3783         ndr_print_ptr(ndr, "printername", r->printername);
3784         ndr->depth++;
3785         if (r->printername) {
3786                 ndr_print_string(ndr, "printername", r->printername);
3787         }
3788         ndr->depth--;
3789         ndr_print_ptr(ndr, "sharename", r->sharename);
3790         ndr->depth++;
3791         if (r->sharename) {
3792                 ndr_print_string(ndr, "sharename", r->sharename);
3793         }
3794         ndr->depth--;
3795         ndr_print_ptr(ndr, "portname", r->portname);
3796         ndr->depth++;
3797         if (r->portname) {
3798                 ndr_print_string(ndr, "portname", r->portname);
3799         }
3800         ndr->depth--;
3801         ndr_print_ptr(ndr, "drivername", r->drivername);
3802         ndr->depth++;
3803         if (r->drivername) {
3804                 ndr_print_string(ndr, "drivername", r->drivername);
3805         }
3806         ndr->depth--;
3807         ndr_print_ptr(ndr, "comment", r->comment);
3808         ndr->depth++;
3809         if (r->comment) {
3810                 ndr_print_string(ndr, "comment", r->comment);
3811         }
3812         ndr->depth--;
3813         ndr_print_ptr(ndr, "location", r->location);
3814         ndr->depth++;
3815         if (r->location) {
3816                 ndr_print_string(ndr, "location", r->location);
3817         }
3818         ndr->depth--;
3819         ndr_print_ptr(ndr, "devmode", r->devmode);
3820         ndr->depth++;
3821         if (r->devmode) {
3822                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3823         }
3824         ndr->depth--;
3825         ndr_print_ptr(ndr, "sepfile", r->sepfile);
3826         ndr->depth++;
3827         if (r->sepfile) {
3828                 ndr_print_string(ndr, "sepfile", r->sepfile);
3829         }
3830         ndr->depth--;
3831         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
3832         ndr->depth++;
3833         if (r->printprocessor) {
3834                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
3835         }
3836         ndr->depth--;
3837         ndr_print_ptr(ndr, "datatype", r->datatype);
3838         ndr->depth++;
3839         if (r->datatype) {
3840                 ndr_print_string(ndr, "datatype", r->datatype);
3841         }
3842         ndr->depth--;
3843         ndr_print_ptr(ndr, "parameters", r->parameters);
3844         ndr->depth++;
3845         if (r->parameters) {
3846                 ndr_print_string(ndr, "parameters", r->parameters);
3847         }
3848         ndr->depth--;
3849         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3850         ndr->depth++;
3851         if (r->secdesc) {
3852                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3853         }
3854         ndr->depth--;
3855         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
3856         ndr_print_uint32(ndr, "priority", r->priority);
3857         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
3858         ndr_print_uint32(ndr, "starttime", r->starttime);
3859         ndr_print_uint32(ndr, "untiltime", r->untiltime);
3860         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
3861         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3862         ndr_print_uint32(ndr, "averageppm", r->averageppm);
3863         ndr->depth--;
3864 }
3865
3866 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
3867 {
3868         if (ndr_flags & NDR_SCALARS) {
3869                 NDR_CHECK(ndr_push_align(ndr, 4));
3870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3871         }
3872         if (ndr_flags & NDR_BUFFERS) {
3873                 if (r->secdesc) {
3874                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3875                 }
3876         }
3877         return NDR_ERR_SUCCESS;
3878 }
3879
3880 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
3881 {
3882         uint32_t _ptr_secdesc;
3883         TALLOC_CTX *_mem_save_secdesc_0;
3884         if (ndr_flags & NDR_SCALARS) {
3885                 NDR_CHECK(ndr_pull_align(ndr, 4));
3886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3887                 if (_ptr_secdesc) {
3888                         NDR_PULL_ALLOC(ndr, r->secdesc);
3889                 } else {
3890                         r->secdesc = NULL;
3891                 }
3892         }
3893         if (ndr_flags & NDR_BUFFERS) {
3894                 if (r->secdesc) {
3895                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3896                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3897                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3899                 }
3900         }
3901         return NDR_ERR_SUCCESS;
3902 }
3903
3904 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
3905 {
3906         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
3907         ndr->depth++;
3908         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3909         ndr->depth++;
3910         if (r->secdesc) {
3911                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3912         }
3913         ndr->depth--;
3914         ndr->depth--;
3915 }
3916
3917 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
3918 {
3919         if (ndr_flags & NDR_SCALARS) {
3920                 NDR_CHECK(ndr_push_align(ndr, 4));
3921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3923                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3924         }
3925         if (ndr_flags & NDR_BUFFERS) {
3926                 if (r->printername) {
3927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3931                 }
3932                 if (r->servername) {
3933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3937                 }
3938         }
3939         return NDR_ERR_SUCCESS;
3940 }
3941
3942 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
3943 {
3944         uint32_t _ptr_printername;
3945         TALLOC_CTX *_mem_save_printername_0;
3946         uint32_t _ptr_servername;
3947         TALLOC_CTX *_mem_save_servername_0;
3948         if (ndr_flags & NDR_SCALARS) {
3949                 NDR_CHECK(ndr_pull_align(ndr, 4));
3950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3951                 if (_ptr_printername) {
3952                         NDR_PULL_ALLOC(ndr, r->printername);
3953                 } else {
3954                         r->printername = NULL;
3955                 }
3956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3957                 if (_ptr_servername) {
3958                         NDR_PULL_ALLOC(ndr, r->servername);
3959                 } else {
3960                         r->servername = NULL;
3961                 }
3962                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3963         }
3964         if (ndr_flags & NDR_BUFFERS) {
3965                 if (r->printername) {
3966                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3967                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3970                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3972                         }
3973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3976                 }
3977                 if (r->servername) {
3978                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3979                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3982                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3984                         }
3985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3988                 }
3989         }
3990         return NDR_ERR_SUCCESS;
3991 }
3992
3993 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
3994 {
3995         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
3996         ndr->depth++;
3997         ndr_print_ptr(ndr, "printername", r->printername);
3998         ndr->depth++;
3999         if (r->printername) {
4000                 ndr_print_string(ndr, "printername", r->printername);
4001         }
4002         ndr->depth--;
4003         ndr_print_ptr(ndr, "servername", r->servername);
4004         ndr->depth++;
4005         if (r->servername) {
4006                 ndr_print_string(ndr, "servername", r->servername);
4007         }
4008         ndr->depth--;
4009         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4010         ndr->depth--;
4011 }
4012
4013 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
4014 {
4015         if (ndr_flags & NDR_SCALARS) {
4016                 NDR_CHECK(ndr_push_align(ndr, 4));
4017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
4018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
4019                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
4020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
4021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
4022         }
4023         if (ndr_flags & NDR_BUFFERS) {
4024                 if (r->printername) {
4025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4029                 }
4030                 if (r->portname) {
4031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4035                 }
4036         }
4037         return NDR_ERR_SUCCESS;
4038 }
4039
4040 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
4041 {
4042         uint32_t _ptr_printername;
4043         TALLOC_CTX *_mem_save_printername_0;
4044         uint32_t _ptr_portname;
4045         TALLOC_CTX *_mem_save_portname_0;
4046         if (ndr_flags & NDR_SCALARS) {
4047                 NDR_CHECK(ndr_pull_align(ndr, 4));
4048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4049                 if (_ptr_printername) {
4050                         NDR_PULL_ALLOC(ndr, r->printername);
4051                 } else {
4052                         r->printername = NULL;
4053                 }
4054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
4055                 if (_ptr_portname) {
4056                         NDR_PULL_ALLOC(ndr, r->portname);
4057                 } else {
4058                         r->portname = NULL;
4059                 }
4060                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
4061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
4062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
4063         }
4064         if (ndr_flags & NDR_BUFFERS) {
4065                 if (r->printername) {
4066                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4067                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4070                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4071                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
4072                         }
4073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4076                 }
4077                 if (r->portname) {
4078                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
4079                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
4080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
4081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
4082                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
4083                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
4084                         }
4085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
4086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
4087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
4096         ndr->depth++;
4097         ndr_print_ptr(ndr, "printername", r->printername);
4098         ndr->depth++;
4099         if (r->printername) {
4100                 ndr_print_string(ndr, "printername", r->printername);
4101         }
4102         ndr->depth--;
4103         ndr_print_ptr(ndr, "portname", r->portname);
4104         ndr->depth++;
4105         if (r->portname) {
4106                 ndr_print_string(ndr, "portname", r->portname);
4107         }
4108         ndr->depth--;
4109         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4110         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
4111         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
4112         ndr->depth--;
4113 }
4114
4115 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
4116 {
4117         if (ndr_flags & NDR_SCALARS) {
4118                 NDR_CHECK(ndr_push_align(ndr, 4));
4119                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
4120         }
4121         if (ndr_flags & NDR_BUFFERS) {
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
4127 {
4128         if (ndr_flags & NDR_SCALARS) {
4129                 NDR_CHECK(ndr_pull_align(ndr, 4));
4130                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
4131         }
4132         if (ndr_flags & NDR_BUFFERS) {
4133         }
4134         return NDR_ERR_SUCCESS;
4135 }
4136
4137 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
4138 {
4139         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
4140         ndr->depth++;
4141         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
4142         ndr->depth--;
4143 }
4144
4145 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
4146 {
4147         if (ndr_flags & NDR_SCALARS) {
4148                 NDR_CHECK(ndr_push_align(ndr, 4));
4149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
4150                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
4151         }
4152         if (ndr_flags & NDR_BUFFERS) {
4153                 if (r->guid) {
4154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4158                 }
4159         }
4160         return NDR_ERR_SUCCESS;
4161 }
4162
4163 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
4164 {
4165         uint32_t _ptr_guid;
4166         TALLOC_CTX *_mem_save_guid_0;
4167         if (ndr_flags & NDR_SCALARS) {
4168                 NDR_CHECK(ndr_pull_align(ndr, 4));
4169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
4170                 if (_ptr_guid) {
4171                         NDR_PULL_ALLOC(ndr, r->guid);
4172                 } else {
4173                         r->guid = NULL;
4174                 }
4175                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
4176         }
4177         if (ndr_flags & NDR_BUFFERS) {
4178                 if (r->guid) {
4179                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4180                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
4181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
4182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
4183                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
4184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
4185                         }
4186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
4187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
4188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
4189                 }
4190         }
4191         return NDR_ERR_SUCCESS;
4192 }
4193
4194 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
4195 {
4196         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
4197         ndr->depth++;
4198         ndr_print_ptr(ndr, "guid", r->guid);
4199         ndr->depth++;
4200         if (r->guid) {
4201                 ndr_print_string(ndr, "guid", r->guid);
4202         }
4203         ndr->depth--;
4204         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
4205         ndr->depth--;
4206 }
4207
4208 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
4209 {
4210         if (ndr_flags & NDR_SCALARS) {
4211                 int level = ndr_push_get_switch_value(ndr, r);
4212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4213                 switch (level) {
4214                         case 0: {
4215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4216                         break; }
4217
4218                         case 1: {
4219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4220                         break; }
4221
4222                         case 2: {
4223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4224                         break; }
4225
4226                         case 3: {
4227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4228                         break; }
4229
4230                         case 4: {
4231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
4232                         break; }
4233
4234                         case 5: {
4235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
4236                         break; }
4237
4238                         case 6: {
4239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
4240                         break; }
4241
4242                         case 7: {
4243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
4244                         break; }
4245
4246                         case 8: {
4247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
4248                         break; }
4249
4250                         case 9: {
4251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
4252                         break; }
4253
4254                         default: {
4255                         break; }
4256
4257                 }
4258         }
4259         if (ndr_flags & NDR_BUFFERS) {
4260                 int level = ndr_push_get_switch_value(ndr, r);
4261                 switch (level) {
4262                         case 0:
4263                                 if (r->info0) {
4264                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4265                                 }
4266                         break;
4267
4268                         case 1:
4269                                 if (r->info1) {
4270                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4271                                 }
4272                         break;
4273
4274                         case 2:
4275                                 if (r->info2) {
4276                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4277                                 }
4278                         break;
4279
4280                         case 3:
4281                                 if (r->info3) {
4282                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4283                                 }
4284                         break;
4285
4286                         case 4:
4287                                 if (r->info4) {
4288                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4289                                 }
4290                         break;
4291
4292                         case 5:
4293                                 if (r->info5) {
4294                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4295                                 }
4296                         break;
4297
4298                         case 6:
4299                                 if (r->info6) {
4300                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4301                                 }
4302                         break;
4303
4304                         case 7:
4305                                 if (r->info7) {
4306                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4307                                 }
4308                         break;
4309
4310                         case 8:
4311                                 if (r->info8) {
4312                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4313                                 }
4314                         break;
4315
4316                         case 9:
4317                                 if (r->info9) {
4318                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4319                                 }
4320                         break;
4321
4322                         default:
4323                         break;
4324
4325                 }
4326         }
4327         return NDR_ERR_SUCCESS;
4328 }
4329
4330 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
4331 {
4332         int level;
4333         uint32_t _level;
4334         TALLOC_CTX *_mem_save_info0_0;
4335         TALLOC_CTX *_mem_save_info1_0;
4336         TALLOC_CTX *_mem_save_info2_0;
4337         TALLOC_CTX *_mem_save_info3_0;
4338         TALLOC_CTX *_mem_save_info4_0;
4339         TALLOC_CTX *_mem_save_info5_0;
4340         TALLOC_CTX *_mem_save_info6_0;
4341         TALLOC_CTX *_mem_save_info7_0;
4342         TALLOC_CTX *_mem_save_info8_0;
4343         TALLOC_CTX *_mem_save_info9_0;
4344         level = ndr_pull_get_switch_value(ndr, r);
4345         if (ndr_flags & NDR_SCALARS) {
4346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4347                 if (_level != level) {
4348                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4349                 }
4350                 switch (level) {
4351                         case 0: {
4352                                 uint32_t _ptr_info0;
4353                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4354                                 if (_ptr_info0) {
4355                                         NDR_PULL_ALLOC(ndr, r->info0);
4356                                 } else {
4357                                         r->info0 = NULL;
4358                                 }
4359                         break; }
4360
4361                         case 1: {
4362                                 uint32_t _ptr_info1;
4363                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4364                                 if (_ptr_info1) {
4365                                         NDR_PULL_ALLOC(ndr, r->info1);
4366                                 } else {
4367                                         r->info1 = NULL;
4368                                 }
4369                         break; }
4370
4371                         case 2: {
4372                                 uint32_t _ptr_info2;
4373                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4374                                 if (_ptr_info2) {
4375                                         NDR_PULL_ALLOC(ndr, r->info2);
4376                                 } else {
4377                                         r->info2 = NULL;
4378                                 }
4379                         break; }
4380
4381                         case 3: {
4382                                 uint32_t _ptr_info3;
4383                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4384                                 if (_ptr_info3) {
4385                                         NDR_PULL_ALLOC(ndr, r->info3);
4386                                 } else {
4387                                         r->info3 = NULL;
4388                                 }
4389                         break; }
4390
4391                         case 4: {
4392                                 uint32_t _ptr_info4;
4393                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
4394                                 if (_ptr_info4) {
4395                                         NDR_PULL_ALLOC(ndr, r->info4);
4396                                 } else {
4397                                         r->info4 = NULL;
4398                                 }
4399                         break; }
4400
4401                         case 5: {
4402                                 uint32_t _ptr_info5;
4403                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
4404                                 if (_ptr_info5) {
4405                                         NDR_PULL_ALLOC(ndr, r->info5);
4406                                 } else {
4407                                         r->info5 = NULL;
4408                                 }
4409                         break; }
4410
4411                         case 6: {
4412                                 uint32_t _ptr_info6;
4413                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
4414                                 if (_ptr_info6) {
4415                                         NDR_PULL_ALLOC(ndr, r->info6);
4416                                 } else {
4417                                         r->info6 = NULL;
4418                                 }
4419                         break; }
4420
4421                         case 7: {
4422                                 uint32_t _ptr_info7;
4423                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
4424                                 if (_ptr_info7) {
4425                                         NDR_PULL_ALLOC(ndr, r->info7);
4426                                 } else {
4427                                         r->info7 = NULL;
4428                                 }
4429                         break; }
4430
4431                         case 8: {
4432                                 uint32_t _ptr_info8;
4433                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
4434                                 if (_ptr_info8) {
4435                                         NDR_PULL_ALLOC(ndr, r->info8);
4436                                 } else {
4437                                         r->info8 = NULL;
4438                                 }
4439                         break; }
4440
4441                         case 9: {
4442                                 uint32_t _ptr_info9;
4443                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
4444                                 if (_ptr_info9) {
4445                                         NDR_PULL_ALLOC(ndr, r->info9);
4446                                 } else {
4447                                         r->info9 = NULL;
4448                                 }
4449                         break; }
4450
4451                         default: {
4452                         break; }
4453
4454                 }
4455         }
4456         if (ndr_flags & NDR_BUFFERS) {
4457                 switch (level) {
4458                         case 0:
4459                                 if (r->info0) {
4460                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4461                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4462                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4463                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4464                                 }
4465                         break;
4466
4467                         case 1:
4468                                 if (r->info1) {
4469                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4470                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4471                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4472                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4473                                 }
4474                         break;
4475
4476                         case 2:
4477                                 if (r->info2) {
4478                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4479                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4480                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4481                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4482                                 }
4483                         break;
4484
4485                         case 3:
4486                                 if (r->info3) {
4487                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4488                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4489                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4490                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4491                                 }
4492                         break;
4493
4494                         case 4:
4495                                 if (r->info4) {
4496                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
4497                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
4498                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4499                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
4500                                 }
4501                         break;
4502
4503                         case 5:
4504                                 if (r->info5) {
4505                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
4506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
4507                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
4509                                 }
4510                         break;
4511
4512                         case 6:
4513                                 if (r->info6) {
4514                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
4515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
4516                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
4518                                 }
4519                         break;
4520
4521                         case 7:
4522                                 if (r->info7) {
4523                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
4524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
4525                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
4527                                 }
4528                         break;
4529
4530                         case 8:
4531                                 if (r->info8) {
4532                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
4534                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
4536                                 }
4537                         break;
4538
4539                         case 9:
4540                                 if (r->info9) {
4541                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
4542                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
4543                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
4545                                 }
4546                         break;
4547
4548                         default:
4549                         break;
4550
4551                 }
4552         }
4553         return NDR_ERR_SUCCESS;
4554 }
4555
4556 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
4557 {
4558         int level;
4559         level = ndr_print_get_switch_value(ndr, r);
4560         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
4561         switch (level) {
4562                 case 0:
4563                         ndr_print_ptr(ndr, "info0", r->info0);
4564                         ndr->depth++;
4565                         if (r->info0) {
4566                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
4567                         }
4568                         ndr->depth--;
4569                 break;
4570
4571                 case 1:
4572                         ndr_print_ptr(ndr, "info1", r->info1);
4573                         ndr->depth++;
4574                         if (r->info1) {
4575                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
4576                         }
4577                         ndr->depth--;
4578                 break;
4579
4580                 case 2:
4581                         ndr_print_ptr(ndr, "info2", r->info2);
4582                         ndr->depth++;
4583                         if (r->info2) {
4584                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
4585                         }
4586                         ndr->depth--;
4587                 break;
4588
4589                 case 3:
4590                         ndr_print_ptr(ndr, "info3", r->info3);
4591                         ndr->depth++;
4592                         if (r->info3) {
4593                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
4594                         }
4595                         ndr->depth--;
4596                 break;
4597
4598                 case 4:
4599                         ndr_print_ptr(ndr, "info4", r->info4);
4600                         ndr->depth++;
4601                         if (r->info4) {
4602                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
4603                         }
4604                         ndr->depth--;
4605                 break;
4606
4607                 case 5:
4608                         ndr_print_ptr(ndr, "info5", r->info5);
4609                         ndr->depth++;
4610                         if (r->info5) {
4611                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
4612                         }
4613                         ndr->depth--;
4614                 break;
4615
4616                 case 6:
4617                         ndr_print_ptr(ndr, "info6", r->info6);
4618                         ndr->depth++;
4619                         if (r->info6) {
4620                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
4621                         }
4622                         ndr->depth--;
4623                 break;
4624
4625                 case 7:
4626                         ndr_print_ptr(ndr, "info7", r->info7);
4627                         ndr->depth++;
4628                         if (r->info7) {
4629                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
4630                         }
4631                         ndr->depth--;
4632                 break;
4633
4634                 case 8:
4635                         ndr_print_ptr(ndr, "info8", r->info8);
4636                         ndr->depth++;
4637                         if (r->info8) {
4638                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
4639                         }
4640                         ndr->depth--;
4641                 break;
4642
4643                 case 9:
4644                         ndr_print_ptr(ndr, "info9", r->info9);
4645                         ndr->depth++;
4646                         if (r->info9) {
4647                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
4648                         }
4649                         ndr->depth--;
4650                 break;
4651
4652                 default:
4653                 break;
4654
4655         }
4656 }
4657
4658 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
4659 {
4660         if (ndr_flags & NDR_SCALARS) {
4661                 NDR_CHECK(ndr_push_align(ndr, 4));
4662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
4664                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4665         }
4666         if (ndr_flags & NDR_BUFFERS) {
4667                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4668         }
4669         return NDR_ERR_SUCCESS;
4670 }
4671
4672 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
4673 {
4674         if (ndr_flags & NDR_SCALARS) {
4675                 NDR_CHECK(ndr_pull_align(ndr, 4));
4676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4677                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
4678                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4679         }
4680         if (ndr_flags & NDR_BUFFERS) {
4681                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4682         }
4683         return NDR_ERR_SUCCESS;
4684 }
4685
4686 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
4687 {
4688         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
4689         ndr->depth++;
4690         ndr_print_uint32(ndr, "level", r->level);
4691         ndr_print_set_switch_value(ndr, &r->info, r->level);
4692         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
4693         ndr->depth--;
4694 }
4695
4696 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
4697 {
4698         if (ndr_flags & NDR_SCALARS) {
4699                 NDR_CHECK(ndr_push_align(ndr, 4));
4700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
4701                 {
4702                         uint32_t _flags_save_string_array = ndr->flags;
4703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4704                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
4705                         ndr->flags = _flags_save_string_array;
4706                 }
4707         }
4708         if (ndr_flags & NDR_BUFFERS) {
4709         }
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
4714 {
4715         if (ndr_flags & NDR_SCALARS) {
4716                 NDR_CHECK(ndr_pull_align(ndr, 4));
4717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
4718                 {
4719                         uint32_t _flags_save_string_array = ndr->flags;
4720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4721                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
4722                         ndr->flags = _flags_save_string_array;
4723                 }
4724         }
4725         if (ndr_flags & NDR_BUFFERS) {
4726         }
4727         return NDR_ERR_SUCCESS;
4728 }
4729
4730 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
4731 {
4732         ndr_print_struct(ndr, name, "spoolss_StringArray");
4733         ndr->depth++;
4734         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
4735         ndr_print_string_array(ndr, "string", r->string);
4736         ndr->depth--;
4737 }
4738
4739 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
4740 {
4741         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
4742 }
4743
4744 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
4745 {
4746         if (ndr_flags & NDR_SCALARS) {
4747                 NDR_CHECK(ndr_push_align(ndr, 4));
4748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4749         }
4750         if (ndr_flags & NDR_BUFFERS) {
4751                 if (r->driver_name) {
4752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4756                 }
4757         }
4758         return NDR_ERR_SUCCESS;
4759 }
4760
4761 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
4762 {
4763         uint32_t _ptr_driver_name;
4764         TALLOC_CTX *_mem_save_driver_name_0;
4765         if (ndr_flags & NDR_SCALARS) {
4766                 NDR_CHECK(ndr_pull_align(ndr, 4));
4767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4768                 if (_ptr_driver_name) {
4769                         NDR_PULL_ALLOC(ndr, r->driver_name);
4770                 } else {
4771                         r->driver_name = NULL;
4772                 }
4773         }
4774         if (ndr_flags & NDR_BUFFERS) {
4775                 if (r->driver_name) {
4776                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4777                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4780                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4781                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4782                         }
4783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4786                 }
4787         }
4788         return NDR_ERR_SUCCESS;
4789 }
4790
4791 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
4792 {
4793         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
4794         ndr->depth++;
4795         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4796         ndr->depth++;
4797         if (r->driver_name) {
4798                 ndr_print_string(ndr, "driver_name", r->driver_name);
4799         }
4800         ndr->depth--;
4801         ndr->depth--;
4802 }
4803
4804 static enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
4805 {
4806         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4807         return NDR_ERR_SUCCESS;
4808 }
4809
4810 static enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
4811 {
4812         uint32_t v;
4813         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4814         *r = v;
4815         return NDR_ERR_SUCCESS;
4816 }
4817
4818 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
4819 {
4820         const char *val = NULL;
4821
4822         switch (r) {
4823                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
4824                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
4825                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
4826                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
4827         }
4828         ndr_print_enum(ndr, name, "ENUM", val, r);
4829 }
4830
4831 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
4832 {
4833         if (ndr_flags & NDR_SCALARS) {
4834                 NDR_CHECK(ndr_push_align(ndr, 4));
4835                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
4838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
4839                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
4840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
4841         }
4842         if (ndr_flags & NDR_BUFFERS) {
4843                 if (r->driver_name) {
4844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4848                 }
4849                 if (r->architecture) {
4850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4854                 }
4855                 if (r->driver_path) {
4856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4860                 }
4861                 if (r->data_file) {
4862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4866                 }
4867                 if (r->config_file) {
4868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4872                 }
4873         }
4874         return NDR_ERR_SUCCESS;
4875 }
4876
4877 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
4878 {
4879         uint32_t _ptr_driver_name;
4880         TALLOC_CTX *_mem_save_driver_name_0;
4881         uint32_t _ptr_architecture;
4882         TALLOC_CTX *_mem_save_architecture_0;
4883         uint32_t _ptr_driver_path;
4884         TALLOC_CTX *_mem_save_driver_path_0;
4885         uint32_t _ptr_data_file;
4886         TALLOC_CTX *_mem_save_data_file_0;
4887         uint32_t _ptr_config_file;
4888         TALLOC_CTX *_mem_save_config_file_0;
4889         if (ndr_flags & NDR_SCALARS) {
4890                 NDR_CHECK(ndr_pull_align(ndr, 4));
4891                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4893                 if (_ptr_driver_name) {
4894                         NDR_PULL_ALLOC(ndr, r->driver_name);
4895                 } else {
4896                         r->driver_name = NULL;
4897                 }
4898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4899                 if (_ptr_architecture) {
4900                         NDR_PULL_ALLOC(ndr, r->architecture);
4901                 } else {
4902                         r->architecture = NULL;
4903                 }
4904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4905                 if (_ptr_driver_path) {
4906                         NDR_PULL_ALLOC(ndr, r->driver_path);
4907                 } else {
4908                         r->driver_path = NULL;
4909                 }
4910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4911                 if (_ptr_data_file) {
4912                         NDR_PULL_ALLOC(ndr, r->data_file);
4913                 } else {
4914                         r->data_file = NULL;
4915                 }
4916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4917                 if (_ptr_config_file) {
4918                         NDR_PULL_ALLOC(ndr, r->config_file);
4919                 } else {
4920                         r->config_file = NULL;
4921                 }
4922         }
4923         if (ndr_flags & NDR_BUFFERS) {
4924                 if (r->driver_name) {
4925                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4926                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4929                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4930                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4931                         }
4932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4933                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4935                 }
4936                 if (r->architecture) {
4937                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4938                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
4940                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
4941                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
4942                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
4943                         }
4944                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
4945                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
4946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4947                 }
4948                 if (r->driver_path) {
4949                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4950                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4951                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
4952                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
4953                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
4954                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
4955                         }
4956                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
4957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
4958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4959                 }
4960                 if (r->data_file) {
4961                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4962                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
4964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
4965                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
4966                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
4967                         }
4968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
4969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
4970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4971                 }
4972                 if (r->config_file) {
4973                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4974                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
4976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
4977                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
4978                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
4979                         }
4980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
4981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
4982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4983                 }
4984         }
4985         return NDR_ERR_SUCCESS;
4986 }
4987
4988 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
4989 {
4990         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
4991         ndr->depth++;
4992         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4993         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4994         ndr->depth++;
4995         if (r->driver_name) {
4996                 ndr_print_string(ndr, "driver_name", r->driver_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "architecture", r->architecture);
5000         ndr->depth++;
5001         if (r->architecture) {
5002                 ndr_print_string(ndr, "architecture", r->architecture);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5006         ndr->depth++;
5007         if (r->driver_path) {
5008                 ndr_print_string(ndr, "driver_path", r->driver_path);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "data_file", r->data_file);
5012         ndr->depth++;
5013         if (r->data_file) {
5014                 ndr_print_string(ndr, "data_file", r->data_file);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "config_file", r->config_file);
5018         ndr->depth++;
5019         if (r->config_file) {
5020                 ndr_print_string(ndr, "config_file", r->config_file);
5021         }
5022         ndr->depth--;
5023         ndr->depth--;
5024 }
5025
5026 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
5027 {
5028         if (ndr_flags & NDR_SCALARS) {
5029                 NDR_CHECK(ndr_push_align(ndr, 4));
5030                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5041         }
5042         if (ndr_flags & NDR_BUFFERS) {
5043                 if (r->driver_name) {
5044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5047                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5048                 }
5049                 if (r->architecture) {
5050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5054                 }
5055                 if (r->driver_path) {
5056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5060                 }
5061                 if (r->data_file) {
5062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5066                 }
5067                 if (r->config_file) {
5068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5072                 }
5073                 if (r->help_file) {
5074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5078                 }
5079                 if (r->monitor_name) {
5080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5084                 }
5085                 if (r->default_datatype) {
5086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5090                 }
5091                 if (r->dependent_files) {
5092                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5093                 }
5094         }
5095         return NDR_ERR_SUCCESS;
5096 }
5097
5098 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
5099 {
5100         uint32_t _ptr_driver_name;
5101         TALLOC_CTX *_mem_save_driver_name_0;
5102         uint32_t _ptr_architecture;
5103         TALLOC_CTX *_mem_save_architecture_0;
5104         uint32_t _ptr_driver_path;
5105         TALLOC_CTX *_mem_save_driver_path_0;
5106         uint32_t _ptr_data_file;
5107         TALLOC_CTX *_mem_save_data_file_0;
5108         uint32_t _ptr_config_file;
5109         TALLOC_CTX *_mem_save_config_file_0;
5110         uint32_t _ptr_help_file;
5111         TALLOC_CTX *_mem_save_help_file_0;
5112         uint32_t _ptr_monitor_name;
5113         TALLOC_CTX *_mem_save_monitor_name_0;
5114         uint32_t _ptr_default_datatype;
5115         TALLOC_CTX *_mem_save_default_datatype_0;
5116         uint32_t _ptr_dependent_files;
5117         TALLOC_CTX *_mem_save_dependent_files_0;
5118         if (ndr_flags & NDR_SCALARS) {
5119                 NDR_CHECK(ndr_pull_align(ndr, 4));
5120                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5122                 if (_ptr_driver_name) {
5123                         NDR_PULL_ALLOC(ndr, r->driver_name);
5124                 } else {
5125                         r->driver_name = NULL;
5126                 }
5127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5128                 if (_ptr_architecture) {
5129                         NDR_PULL_ALLOC(ndr, r->architecture);
5130                 } else {
5131                         r->architecture = NULL;
5132                 }
5133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5134                 if (_ptr_driver_path) {
5135                         NDR_PULL_ALLOC(ndr, r->driver_path);
5136                 } else {
5137                         r->driver_path = NULL;
5138                 }
5139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5140                 if (_ptr_data_file) {
5141                         NDR_PULL_ALLOC(ndr, r->data_file);
5142                 } else {
5143                         r->data_file = NULL;
5144                 }
5145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5146                 if (_ptr_config_file) {
5147                         NDR_PULL_ALLOC(ndr, r->config_file);
5148                 } else {
5149                         r->config_file = NULL;
5150                 }
5151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5152                 if (_ptr_help_file) {
5153                         NDR_PULL_ALLOC(ndr, r->help_file);
5154                 } else {
5155                         r->help_file = NULL;
5156                 }
5157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5158                 if (_ptr_monitor_name) {
5159                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5160                 } else {
5161                         r->monitor_name = NULL;
5162                 }
5163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5164                 if (_ptr_default_datatype) {
5165                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5166                 } else {
5167                         r->default_datatype = NULL;
5168                 }
5169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5171                 if (_ptr_dependent_files) {
5172                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5173                 } else {
5174                         r->dependent_files = NULL;
5175                 }
5176         }
5177         if (ndr_flags & NDR_BUFFERS) {
5178                 if (r->driver_name) {
5179                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5180                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5183                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5185                         }
5186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5189                 }
5190                 if (r->architecture) {
5191                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5192                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5194                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5195                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5196                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5197                         }
5198                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5199                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5201                 }
5202                 if (r->driver_path) {
5203                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5204                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5205                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5206                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5207                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5208                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5209                         }
5210                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5211                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5213                 }
5214                 if (r->data_file) {
5215                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5216                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5218                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5219                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5220                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5221                         }
5222                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5223                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5225                 }
5226                 if (r->config_file) {
5227                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5228                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5229                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5230                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5231                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5232                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5233                         }
5234                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5235                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5236                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5237                 }
5238                 if (r->help_file) {
5239                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5240                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5241                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5242                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5243                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5244                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5245                         }
5246                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5247                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5249                 }
5250                 if (r->monitor_name) {
5251                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5252                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5255                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5256                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5257                         }
5258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5261                 }
5262                 if (r->default_datatype) {
5263                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5264                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5267                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5268                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5269                         }
5270                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5271                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5273                 }
5274                 if (r->dependent_files) {
5275                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5276                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5277                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5279                 }
5280         }
5281         return NDR_ERR_SUCCESS;
5282 }
5283
5284 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
5285 {
5286         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
5287         ndr->depth++;
5288         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5289         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5290         ndr->depth++;
5291         if (r->driver_name) {
5292                 ndr_print_string(ndr, "driver_name", r->driver_name);
5293         }
5294         ndr->depth--;
5295         ndr_print_ptr(ndr, "architecture", r->architecture);
5296         ndr->depth++;
5297         if (r->architecture) {
5298                 ndr_print_string(ndr, "architecture", r->architecture);
5299         }
5300         ndr->depth--;
5301         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5302         ndr->depth++;
5303         if (r->driver_path) {
5304                 ndr_print_string(ndr, "driver_path", r->driver_path);
5305         }
5306         ndr->depth--;
5307         ndr_print_ptr(ndr, "data_file", r->data_file);
5308         ndr->depth++;
5309         if (r->data_file) {
5310                 ndr_print_string(ndr, "data_file", r->data_file);
5311         }
5312         ndr->depth--;
5313         ndr_print_ptr(ndr, "config_file", r->config_file);
5314         ndr->depth++;
5315         if (r->config_file) {
5316                 ndr_print_string(ndr, "config_file", r->config_file);
5317         }
5318         ndr->depth--;
5319         ndr_print_ptr(ndr, "help_file", r->help_file);
5320         ndr->depth++;
5321         if (r->help_file) {
5322                 ndr_print_string(ndr, "help_file", r->help_file);
5323         }
5324         ndr->depth--;
5325         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5326         ndr->depth++;
5327         if (r->monitor_name) {
5328                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5329         }
5330         ndr->depth--;
5331         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5332         ndr->depth++;
5333         if (r->default_datatype) {
5334                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5335         }
5336         ndr->depth--;
5337         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
5338         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5339         ndr->depth++;
5340         if (r->dependent_files) {
5341                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5342         }
5343         ndr->depth--;
5344         ndr->depth--;
5345 }
5346
5347 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
5348 {
5349         if (ndr_flags & NDR_SCALARS) {
5350                 NDR_CHECK(ndr_push_align(ndr, 4));
5351                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5364         }
5365         if (ndr_flags & NDR_BUFFERS) {
5366                 if (r->driver_name) {
5367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5371                 }
5372                 if (r->architecture) {
5373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5377                 }
5378                 if (r->driver_path) {
5379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5383                 }
5384                 if (r->data_file) {
5385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5388                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5389                 }
5390                 if (r->config_file) {
5391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5395                 }
5396                 if (r->help_file) {
5397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5401                 }
5402                 if (r->monitor_name) {
5403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5407                 }
5408                 if (r->default_datatype) {
5409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5413                 }
5414                 if (r->dependent_files) {
5415                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5416                 }
5417                 if (r->previous_names) {
5418                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5419                 }
5420         }
5421         return NDR_ERR_SUCCESS;
5422 }
5423
5424 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
5425 {
5426         uint32_t _ptr_driver_name;
5427         TALLOC_CTX *_mem_save_driver_name_0;
5428         uint32_t _ptr_architecture;
5429         TALLOC_CTX *_mem_save_architecture_0;
5430         uint32_t _ptr_driver_path;
5431         TALLOC_CTX *_mem_save_driver_path_0;
5432         uint32_t _ptr_data_file;
5433         TALLOC_CTX *_mem_save_data_file_0;
5434         uint32_t _ptr_config_file;
5435         TALLOC_CTX *_mem_save_config_file_0;
5436         uint32_t _ptr_help_file;
5437         TALLOC_CTX *_mem_save_help_file_0;
5438         uint32_t _ptr_monitor_name;
5439         TALLOC_CTX *_mem_save_monitor_name_0;
5440         uint32_t _ptr_default_datatype;
5441         TALLOC_CTX *_mem_save_default_datatype_0;
5442         uint32_t _ptr_dependent_files;
5443         TALLOC_CTX *_mem_save_dependent_files_0;
5444         uint32_t _ptr_previous_names;
5445         TALLOC_CTX *_mem_save_previous_names_0;
5446         if (ndr_flags & NDR_SCALARS) {
5447                 NDR_CHECK(ndr_pull_align(ndr, 4));
5448                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5449                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5450                 if (_ptr_driver_name) {
5451                         NDR_PULL_ALLOC(ndr, r->driver_name);
5452                 } else {
5453                         r->driver_name = NULL;
5454                 }
5455                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5456                 if (_ptr_architecture) {
5457                         NDR_PULL_ALLOC(ndr, r->architecture);
5458                 } else {
5459                         r->architecture = NULL;
5460                 }
5461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5462                 if (_ptr_driver_path) {
5463                         NDR_PULL_ALLOC(ndr, r->driver_path);
5464                 } else {
5465                         r->driver_path = NULL;
5466                 }
5467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5468                 if (_ptr_data_file) {
5469                         NDR_PULL_ALLOC(ndr, r->data_file);
5470                 } else {
5471                         r->data_file = NULL;
5472                 }
5473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5474                 if (_ptr_config_file) {
5475                         NDR_PULL_ALLOC(ndr, r->config_file);
5476                 } else {
5477                         r->config_file = NULL;
5478                 }
5479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5480                 if (_ptr_help_file) {
5481                         NDR_PULL_ALLOC(ndr, r->help_file);
5482                 } else {
5483                         r->help_file = NULL;
5484                 }
5485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5486                 if (_ptr_monitor_name) {
5487                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5488                 } else {
5489                         r->monitor_name = NULL;
5490                 }
5491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5492                 if (_ptr_default_datatype) {
5493                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5494                 } else {
5495                         r->default_datatype = NULL;
5496                 }
5497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5499                 if (_ptr_dependent_files) {
5500                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5501                 } else {
5502                         r->dependent_files = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5506                 if (_ptr_previous_names) {
5507                         NDR_PULL_ALLOC(ndr, r->previous_names);
5508                 } else {
5509                         r->previous_names = NULL;
5510                 }
5511         }
5512         if (ndr_flags & NDR_BUFFERS) {
5513                 if (r->driver_name) {
5514                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5515                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5516                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5517                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5518                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5519                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5520                         }
5521                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5524                 }
5525                 if (r->architecture) {
5526                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5527                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5530                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5531                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5532                         }
5533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5536                 }
5537                 if (r->driver_path) {
5538                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5539                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5542                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5543                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5544                         }
5545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5548                 }
5549                 if (r->data_file) {
5550                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5551                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5554                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5555                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5556                         }
5557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5560                 }
5561                 if (r->config_file) {
5562                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5563                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5566                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5568                         }
5569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5572                 }
5573                 if (r->help_file) {
5574                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5575                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5576                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5577                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5578                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5579                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5580                         }
5581                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5582                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5584                 }
5585                 if (r->monitor_name) {
5586                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5587                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5588                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5589                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5590                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5591                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5592                         }
5593                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5594                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5596                 }
5597                 if (r->default_datatype) {
5598                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5599                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5600                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5601                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5602                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5603                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5604                         }
5605                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5606                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5608                 }
5609                 if (r->dependent_files) {
5610                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5611                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5612                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5614                 }
5615                 if (r->previous_names) {
5616                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5617                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
5618                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
5620                 }
5621         }
5622         return NDR_ERR_SUCCESS;
5623 }
5624
5625 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
5626 {
5627         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
5628         ndr->depth++;
5629         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5630         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5631         ndr->depth++;
5632         if (r->driver_name) {
5633                 ndr_print_string(ndr, "driver_name", r->driver_name);
5634         }
5635         ndr->depth--;
5636         ndr_print_ptr(ndr, "architecture", r->architecture);
5637         ndr->depth++;
5638         if (r->architecture) {
5639                 ndr_print_string(ndr, "architecture", r->architecture);
5640         }
5641         ndr->depth--;
5642         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5643         ndr->depth++;
5644         if (r->driver_path) {
5645                 ndr_print_string(ndr, "driver_path", r->driver_path);
5646         }
5647         ndr->depth--;
5648         ndr_print_ptr(ndr, "data_file", r->data_file);
5649         ndr->depth++;
5650         if (r->data_file) {
5651                 ndr_print_string(ndr, "data_file", r->data_file);
5652         }
5653         ndr->depth--;
5654         ndr_print_ptr(ndr, "config_file", r->config_file);
5655         ndr->depth++;
5656         if (r->config_file) {
5657                 ndr_print_string(ndr, "config_file", r->config_file);
5658         }
5659         ndr->depth--;
5660         ndr_print_ptr(ndr, "help_file", r->help_file);
5661         ndr->depth++;
5662         if (r->help_file) {
5663                 ndr_print_string(ndr, "help_file", r->help_file);
5664         }
5665         ndr->depth--;
5666         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5667         ndr->depth++;
5668         if (r->monitor_name) {
5669                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5670         }
5671         ndr->depth--;
5672         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5673         ndr->depth++;
5674         if (r->default_datatype) {
5675                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5676         }
5677         ndr->depth--;
5678         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
5679         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5680         ndr->depth++;
5681         if (r->dependent_files) {
5682                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5683         }
5684         ndr->depth--;
5685         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
5686         ndr_print_ptr(ndr, "previous_names", r->previous_names);
5687         ndr->depth++;
5688         if (r->previous_names) {
5689                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
5690         }
5691         ndr->depth--;
5692         ndr->depth--;
5693 }
5694
5695 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
5696 {
5697         if (ndr_flags & NDR_SCALARS) {
5698                 NDR_CHECK(ndr_push_align(ndr, 8));
5699                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5712                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
5713                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
5714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
5715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
5716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
5717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
5718         }
5719         if (ndr_flags & NDR_BUFFERS) {
5720                 if (r->driver_name) {
5721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5725                 }
5726                 if (r->architecture) {
5727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5731                 }
5732                 if (r->driver_path) {
5733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5737                 }
5738                 if (r->data_file) {
5739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5743                 }
5744                 if (r->config_file) {
5745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5749                 }
5750                 if (r->help_file) {
5751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5755                 }
5756                 if (r->monitor_name) {
5757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5761                 }
5762                 if (r->default_datatype) {
5763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5766                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5767                 }
5768                 if (r->dependent_files) {
5769                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5770                 }
5771                 if (r->previous_names) {
5772                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5773                 }
5774                 if (r->manufacturer_name) {
5775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5778                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5779                 }
5780                 if (r->manufacturer_url) {
5781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5784                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5785                 }
5786                 if (r->hardware_id) {
5787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5790                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5791                 }
5792                 if (r->provider) {
5793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5796                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5797                 }
5798         }
5799         return NDR_ERR_SUCCESS;
5800 }
5801
5802 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
5803 {
5804         uint32_t _ptr_driver_name;
5805         TALLOC_CTX *_mem_save_driver_name_0;
5806         uint32_t _ptr_architecture;
5807         TALLOC_CTX *_mem_save_architecture_0;
5808         uint32_t _ptr_driver_path;
5809         TALLOC_CTX *_mem_save_driver_path_0;
5810         uint32_t _ptr_data_file;
5811         TALLOC_CTX *_mem_save_data_file_0;
5812         uint32_t _ptr_config_file;
5813         TALLOC_CTX *_mem_save_config_file_0;
5814         uint32_t _ptr_help_file;
5815         TALLOC_CTX *_mem_save_help_file_0;
5816         uint32_t _ptr_monitor_name;
5817         TALLOC_CTX *_mem_save_monitor_name_0;
5818         uint32_t _ptr_default_datatype;
5819         TALLOC_CTX *_mem_save_default_datatype_0;
5820         uint32_t _ptr_dependent_files;
5821         TALLOC_CTX *_mem_save_dependent_files_0;
5822         uint32_t _ptr_previous_names;
5823         TALLOC_CTX *_mem_save_previous_names_0;
5824         uint32_t _ptr_manufacturer_name;
5825         TALLOC_CTX *_mem_save_manufacturer_name_0;
5826         uint32_t _ptr_manufacturer_url;
5827         TALLOC_CTX *_mem_save_manufacturer_url_0;
5828         uint32_t _ptr_hardware_id;
5829         TALLOC_CTX *_mem_save_hardware_id_0;
5830         uint32_t _ptr_provider;
5831         TALLOC_CTX *_mem_save_provider_0;
5832         if (ndr_flags & NDR_SCALARS) {
5833                 NDR_CHECK(ndr_pull_align(ndr, 8));
5834                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5836                 if (_ptr_driver_name) {
5837                         NDR_PULL_ALLOC(ndr, r->driver_name);
5838                 } else {
5839                         r->driver_name = NULL;
5840                 }
5841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5842                 if (_ptr_architecture) {
5843                         NDR_PULL_ALLOC(ndr, r->architecture);
5844                 } else {
5845                         r->architecture = NULL;
5846                 }
5847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5848                 if (_ptr_driver_path) {
5849                         NDR_PULL_ALLOC(ndr, r->driver_path);
5850                 } else {
5851                         r->driver_path = NULL;
5852                 }
5853                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5854                 if (_ptr_data_file) {
5855                         NDR_PULL_ALLOC(ndr, r->data_file);
5856                 } else {
5857                         r->data_file = NULL;
5858                 }
5859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5860                 if (_ptr_config_file) {
5861                         NDR_PULL_ALLOC(ndr, r->config_file);
5862                 } else {
5863                         r->config_file = NULL;
5864                 }
5865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5866                 if (_ptr_help_file) {
5867                         NDR_PULL_ALLOC(ndr, r->help_file);
5868                 } else {
5869                         r->help_file = NULL;
5870                 }
5871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5872                 if (_ptr_monitor_name) {
5873                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5874                 } else {
5875                         r->monitor_name = NULL;
5876                 }
5877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5878                 if (_ptr_default_datatype) {
5879                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5880                 } else {
5881                         r->default_datatype = NULL;
5882                 }
5883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5885                 if (_ptr_dependent_files) {
5886                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5887                 } else {
5888                         r->dependent_files = NULL;
5889                 }
5890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5892                 if (_ptr_previous_names) {
5893                         NDR_PULL_ALLOC(ndr, r->previous_names);
5894                 } else {
5895                         r->previous_names = NULL;
5896                 }
5897                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
5898                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
5899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
5900                 if (_ptr_manufacturer_name) {
5901                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
5902                 } else {
5903                         r->manufacturer_name = NULL;
5904                 }
5905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
5906                 if (_ptr_manufacturer_url) {
5907                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
5908                 } else {
5909                         r->manufacturer_url = NULL;
5910                 }
5911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
5912                 if (_ptr_hardware_id) {
5913                         NDR_PULL_ALLOC(ndr, r->hardware_id);
5914                 } else {
5915                         r->hardware_id = NULL;
5916                 }
5917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
5918                 if (_ptr_provider) {
5919                         NDR_PULL_ALLOC(ndr, r->provider);
5920                 } else {
5921                         r->provider = NULL;
5922                 }
5923         }
5924         if (ndr_flags & NDR_BUFFERS) {
5925                 if (r->driver_name) {
5926                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5927                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5930                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5931                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5932                         }
5933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5936                 }
5937                 if (r->architecture) {
5938                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5939                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5942                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5943                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5944                         }
5945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5948                 }
5949                 if (r->driver_path) {
5950                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5951                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5954                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5955                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5956                         }
5957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5960                 }
5961                 if (r->data_file) {
5962                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5963                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5966                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5967                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5968                         }
5969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5972                 }
5973                 if (r->config_file) {
5974                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5975                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5977                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5978                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5979                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5980                         }
5981                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5982                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5984                 }
5985                 if (r->help_file) {
5986                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5987                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5990                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5991                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5992                         }
5993                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5994                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5996                 }
5997                 if (r->monitor_name) {
5998                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5999                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6002                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6003                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
6004                         }
6005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6008                 }
6009                 if (r->default_datatype) {
6010                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6011                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6014                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
6016                         }
6017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6020                 }
6021                 if (r->dependent_files) {
6022                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6023                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6024                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6026                 }
6027                 if (r->previous_names) {
6028                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6030                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6032                 }
6033                 if (r->manufacturer_name) {
6034                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6038                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6039                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
6040                         }
6041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6044                 }
6045                 if (r->manufacturer_url) {
6046                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6047                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6050                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6051                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
6052                         }
6053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6056                 }
6057                 if (r->hardware_id) {
6058                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6059                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6062                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
6064                         }
6065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6068                 }
6069                 if (r->provider) {
6070                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6071                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6074                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6075                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
6076                         }
6077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6080                 }
6081         }
6082         return NDR_ERR_SUCCESS;
6083 }
6084
6085 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
6086 {
6087         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
6088         ndr->depth++;
6089         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6090         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6091         ndr->depth++;
6092         if (r->driver_name) {
6093                 ndr_print_string(ndr, "driver_name", r->driver_name);
6094         }
6095         ndr->depth--;
6096         ndr_print_ptr(ndr, "architecture", r->architecture);
6097         ndr->depth++;
6098         if (r->architecture) {
6099                 ndr_print_string(ndr, "architecture", r->architecture);
6100         }
6101         ndr->depth--;
6102         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6103         ndr->depth++;
6104         if (r->driver_path) {
6105                 ndr_print_string(ndr, "driver_path", r->driver_path);
6106         }
6107         ndr->depth--;
6108         ndr_print_ptr(ndr, "data_file", r->data_file);
6109         ndr->depth++;
6110         if (r->data_file) {
6111                 ndr_print_string(ndr, "data_file", r->data_file);
6112         }
6113         ndr->depth--;
6114         ndr_print_ptr(ndr, "config_file", r->config_file);
6115         ndr->depth++;
6116         if (r->config_file) {
6117                 ndr_print_string(ndr, "config_file", r->config_file);
6118         }
6119         ndr->depth--;
6120         ndr_print_ptr(ndr, "help_file", r->help_file);
6121         ndr->depth++;
6122         if (r->help_file) {
6123                 ndr_print_string(ndr, "help_file", r->help_file);
6124         }
6125         ndr->depth--;
6126         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6127         ndr->depth++;
6128         if (r->monitor_name) {
6129                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6130         }
6131         ndr->depth--;
6132         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6133         ndr->depth++;
6134         if (r->default_datatype) {
6135                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6136         }
6137         ndr->depth--;
6138         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
6139         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6140         ndr->depth++;
6141         if (r->dependent_files) {
6142                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6143         }
6144         ndr->depth--;
6145         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
6146         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6147         ndr->depth++;
6148         if (r->previous_names) {
6149                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6150         }
6151         ndr->depth--;
6152         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6153         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6154         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6155         ndr->depth++;
6156         if (r->manufacturer_name) {
6157                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6158         }
6159         ndr->depth--;
6160         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6161         ndr->depth++;
6162         if (r->manufacturer_url) {
6163                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6164         }
6165         ndr->depth--;
6166         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6167         ndr->depth++;
6168         if (r->hardware_id) {
6169                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6170         }
6171         ndr->depth--;
6172         ndr_print_ptr(ndr, "provider", r->provider);
6173         ndr->depth++;
6174         if (r->provider) {
6175                 ndr_print_string(ndr, "provider", r->provider);
6176         }
6177         ndr->depth--;
6178         ndr->depth--;
6179 }
6180
6181 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
6182 {
6183         if (ndr_flags & NDR_SCALARS) {
6184                 NDR_CHECK(ndr_push_align(ndr, 8));
6185                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6190                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
6192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
6193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
6194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
6196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
6198                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
6199                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
6200                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
6201                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
6202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
6203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
6204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
6205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
6206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6207                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
6208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
6209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
6210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
6212                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
6213                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
6214         }
6215         if (ndr_flags & NDR_BUFFERS) {
6216                 if (r->driver_name) {
6217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6221                 }
6222                 if (r->architecture) {
6223                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6226                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6227                 }
6228                 if (r->driver_path) {
6229                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6232                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6233                 }
6234                 if (r->data_file) {
6235                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6238                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6239                 }
6240                 if (r->config_file) {
6241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6245                 }
6246                 if (r->help_file) {
6247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6251                 }
6252                 if (r->monitor_name) {
6253                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6254                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6256                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6257                 }
6258                 if (r->default_datatype) {
6259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6263                 }
6264                 if (r->dependent_files) {
6265                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6266                 }
6267                 if (r->previous_names) {
6268                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6269                 }
6270                 if (r->manufacturer_name) {
6271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6274                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6275                 }
6276                 if (r->manufacturer_url) {
6277                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6280                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6281                 }
6282                 if (r->hardware_id) {
6283                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6284                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6286                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6287                 }
6288                 if (r->provider) {
6289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6293                 }
6294                 if (r->print_processor) {
6295                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6298                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6299                 }
6300                 if (r->vendor_setup) {
6301                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6302                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6303                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6304                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6305                 }
6306                 if (r->color_profiles) {
6307                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6308                 }
6309                 if (r->inf_path) {
6310                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6313                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6314                 }
6315                 if (r->core_driver_dependencies) {
6316                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6317                 }
6318         }
6319         return NDR_ERR_SUCCESS;
6320 }
6321
6322 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
6323 {
6324         uint32_t _ptr_driver_name;
6325         TALLOC_CTX *_mem_save_driver_name_0;
6326         uint32_t _ptr_architecture;
6327         TALLOC_CTX *_mem_save_architecture_0;
6328         uint32_t _ptr_driver_path;
6329         TALLOC_CTX *_mem_save_driver_path_0;
6330         uint32_t _ptr_data_file;
6331         TALLOC_CTX *_mem_save_data_file_0;
6332         uint32_t _ptr_config_file;
6333         TALLOC_CTX *_mem_save_config_file_0;
6334         uint32_t _ptr_help_file;
6335         TALLOC_CTX *_mem_save_help_file_0;
6336         uint32_t _ptr_monitor_name;
6337         TALLOC_CTX *_mem_save_monitor_name_0;
6338         uint32_t _ptr_default_datatype;
6339         TALLOC_CTX *_mem_save_default_datatype_0;
6340         uint32_t _ptr_dependent_files;
6341         TALLOC_CTX *_mem_save_dependent_files_0;
6342         uint32_t _ptr_previous_names;
6343         TALLOC_CTX *_mem_save_previous_names_0;
6344         uint32_t _ptr_manufacturer_name;
6345         TALLOC_CTX *_mem_save_manufacturer_name_0;
6346         uint32_t _ptr_manufacturer_url;
6347         TALLOC_CTX *_mem_save_manufacturer_url_0;
6348         uint32_t _ptr_hardware_id;
6349         TALLOC_CTX *_mem_save_hardware_id_0;
6350         uint32_t _ptr_provider;
6351         TALLOC_CTX *_mem_save_provider_0;
6352         uint32_t _ptr_print_processor;
6353         TALLOC_CTX *_mem_save_print_processor_0;
6354         uint32_t _ptr_vendor_setup;
6355         TALLOC_CTX *_mem_save_vendor_setup_0;
6356         uint32_t _ptr_color_profiles;
6357         TALLOC_CTX *_mem_save_color_profiles_0;
6358         uint32_t _ptr_inf_path;
6359         TALLOC_CTX *_mem_save_inf_path_0;
6360         uint32_t _ptr_core_driver_dependencies;
6361         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
6362         if (ndr_flags & NDR_SCALARS) {
6363                 NDR_CHECK(ndr_pull_align(ndr, 8));
6364                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6365                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6366                 if (_ptr_driver_name) {
6367                         NDR_PULL_ALLOC(ndr, r->driver_name);
6368                 } else {
6369                         r->driver_name = NULL;
6370                 }
6371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6372                 if (_ptr_architecture) {
6373                         NDR_PULL_ALLOC(ndr, r->architecture);
6374                 } else {
6375                         r->architecture = NULL;
6376                 }
6377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6378                 if (_ptr_driver_path) {
6379                         NDR_PULL_ALLOC(ndr, r->driver_path);
6380                 } else {
6381                         r->driver_path = NULL;
6382                 }
6383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6384                 if (_ptr_data_file) {
6385                         NDR_PULL_ALLOC(ndr, r->data_file);
6386                 } else {
6387                         r->data_file = NULL;
6388                 }
6389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6390                 if (_ptr_config_file) {
6391                         NDR_PULL_ALLOC(ndr, r->config_file);
6392                 } else {
6393                         r->config_file = NULL;
6394                 }
6395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
6396                 if (_ptr_help_file) {
6397                         NDR_PULL_ALLOC(ndr, r->help_file);
6398                 } else {
6399                         r->help_file = NULL;
6400                 }
6401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
6402                 if (_ptr_monitor_name) {
6403                         NDR_PULL_ALLOC(ndr, r->monitor_name);
6404                 } else {
6405                         r->monitor_name = NULL;
6406                 }
6407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
6408                 if (_ptr_default_datatype) {
6409                         NDR_PULL_ALLOC(ndr, r->default_datatype);
6410                 } else {
6411                         r->default_datatype = NULL;
6412                 }
6413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
6414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
6415                 if (_ptr_dependent_files) {
6416                         NDR_PULL_ALLOC(ndr, r->dependent_files);
6417                 } else {
6418                         r->dependent_files = NULL;
6419                 }
6420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
6421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
6422                 if (_ptr_previous_names) {
6423                         NDR_PULL_ALLOC(ndr, r->previous_names);
6424                 } else {
6425                         r->previous_names = NULL;
6426                 }
6427                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
6428                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
6429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
6430                 if (_ptr_manufacturer_name) {
6431                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
6432                 } else {
6433                         r->manufacturer_name = NULL;
6434                 }
6435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
6436                 if (_ptr_manufacturer_url) {
6437                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
6438                 } else {
6439                         r->manufacturer_url = NULL;
6440                 }
6441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
6442                 if (_ptr_hardware_id) {
6443                         NDR_PULL_ALLOC(ndr, r->hardware_id);
6444                 } else {
6445                         r->hardware_id = NULL;
6446                 }
6447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
6448                 if (_ptr_provider) {
6449                         NDR_PULL_ALLOC(ndr, r->provider);
6450                 } else {
6451                         r->provider = NULL;
6452                 }
6453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
6454                 if (_ptr_print_processor) {
6455                         NDR_PULL_ALLOC(ndr, r->print_processor);
6456                 } else {
6457                         r->print_processor = NULL;
6458                 }
6459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
6460                 if (_ptr_vendor_setup) {
6461                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
6462                 } else {
6463                         r->vendor_setup = NULL;
6464                 }
6465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
6466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
6467                 if (_ptr_color_profiles) {
6468                         NDR_PULL_ALLOC(ndr, r->color_profiles);
6469                 } else {
6470                         r->color_profiles = NULL;
6471                 }
6472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
6473                 if (_ptr_inf_path) {
6474                         NDR_PULL_ALLOC(ndr, r->inf_path);
6475                 } else {
6476                         r->inf_path = NULL;
6477                 }
6478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
6479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
6480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
6481                 if (_ptr_core_driver_dependencies) {
6482                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
6483                 } else {
6484                         r->core_driver_dependencies = NULL;
6485                 }
6486                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
6487                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
6488         }
6489         if (ndr_flags & NDR_BUFFERS) {
6490                 if (r->driver_name) {
6491                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6492                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6493                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6494                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6495                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6496                                 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));
6497                         }
6498                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6499                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6501                 }
6502                 if (r->architecture) {
6503                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6504                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6505                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6506                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6507                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6508                                 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));
6509                         }
6510                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6511                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6513                 }
6514                 if (r->driver_path) {
6515                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6516                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6519                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6520                                 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));
6521                         }
6522                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6523                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6525                 }
6526                 if (r->data_file) {
6527                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6528                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6529                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6530                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6531                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6532                                 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));
6533                         }
6534                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6535                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6536                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6537                 }
6538                 if (r->config_file) {
6539                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6540                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6541                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6542                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6543                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6544                                 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));
6545                         }
6546                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6547                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6549                 }
6550                 if (r->help_file) {
6551                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6552                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
6553                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
6554                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
6555                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
6556                                 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));
6557                         }
6558                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
6559                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
6560                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
6561                 }
6562                 if (r->monitor_name) {
6563                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6564                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6565                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6566                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6567                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6568                                 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));
6569                         }
6570                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6571                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6573                 }
6574                 if (r->default_datatype) {
6575                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6576                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6577                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6578                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6579                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6580                                 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));
6581                         }
6582                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6583                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6585                 }
6586                 if (r->dependent_files) {
6587                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6588                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6589                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6591                 }
6592                 if (r->previous_names) {
6593                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6594                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6595                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6597                 }
6598                 if (r->manufacturer_name) {
6599                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6600                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6601                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6602                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6603                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6604                                 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));
6605                         }
6606                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6607                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6609                 }
6610                 if (r->manufacturer_url) {
6611                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6612                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6615                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6616                                 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));
6617                         }
6618                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6619                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6621                 }
6622                 if (r->hardware_id) {
6623                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6624                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6625                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6626                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6627                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6628                                 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));
6629                         }
6630                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6631                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6633                 }
6634                 if (r->provider) {
6635                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6636                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6638                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6639                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6640                                 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));
6641                         }
6642                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6643                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6645                 }
6646                 if (r->print_processor) {
6647                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6648                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6649                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6650                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6651                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6652                                 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));
6653                         }
6654                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6655                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6656                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6657                 }
6658                 if (r->vendor_setup) {
6659                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
6660                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
6661                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
6662                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
6663                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
6664                                 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));
6665                         }
6666                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
6667                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
6668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
6669                 }
6670                 if (r->color_profiles) {
6671                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
6672                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
6673                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
6675                 }
6676                 if (r->inf_path) {
6677                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6678                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
6679                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
6680                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
6681                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
6682                                 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));
6683                         }
6684                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
6685                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
6686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
6687                 }
6688                 if (r->core_driver_dependencies) {
6689                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
6690                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
6691                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
6693                 }
6694         }
6695         return NDR_ERR_SUCCESS;
6696 }
6697
6698 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
6699 {
6700         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
6701         ndr->depth++;
6702         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6703         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6704         ndr->depth++;
6705         if (r->driver_name) {
6706                 ndr_print_string(ndr, "driver_name", r->driver_name);
6707         }
6708         ndr->depth--;
6709         ndr_print_ptr(ndr, "architecture", r->architecture);
6710         ndr->depth++;
6711         if (r->architecture) {
6712                 ndr_print_string(ndr, "architecture", r->architecture);
6713         }
6714         ndr->depth--;
6715         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6716         ndr->depth++;
6717         if (r->driver_path) {
6718                 ndr_print_string(ndr, "driver_path", r->driver_path);
6719         }
6720         ndr->depth--;
6721         ndr_print_ptr(ndr, "data_file", r->data_file);
6722         ndr->depth++;
6723         if (r->data_file) {
6724                 ndr_print_string(ndr, "data_file", r->data_file);
6725         }
6726         ndr->depth--;
6727         ndr_print_ptr(ndr, "config_file", r->config_file);
6728         ndr->depth++;
6729         if (r->config_file) {
6730                 ndr_print_string(ndr, "config_file", r->config_file);
6731         }
6732         ndr->depth--;
6733         ndr_print_ptr(ndr, "help_file", r->help_file);
6734         ndr->depth++;
6735         if (r->help_file) {
6736                 ndr_print_string(ndr, "help_file", r->help_file);
6737         }
6738         ndr->depth--;
6739         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6740         ndr->depth++;
6741         if (r->monitor_name) {
6742                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6743         }
6744         ndr->depth--;
6745         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6746         ndr->depth++;
6747         if (r->default_datatype) {
6748                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6749         }
6750         ndr->depth--;
6751         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);
6752         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6753         ndr->depth++;
6754         if (r->dependent_files) {
6755                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6756         }
6757         ndr->depth--;
6758         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);
6759         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6760         ndr->depth++;
6761         if (r->previous_names) {
6762                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6763         }
6764         ndr->depth--;
6765         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6766         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6767         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6768         ndr->depth++;
6769         if (r->manufacturer_name) {
6770                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6771         }
6772         ndr->depth--;
6773         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6774         ndr->depth++;
6775         if (r->manufacturer_url) {
6776                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6777         }
6778         ndr->depth--;
6779         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6780         ndr->depth++;
6781         if (r->hardware_id) {
6782                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6783         }
6784         ndr->depth--;
6785         ndr_print_ptr(ndr, "provider", r->provider);
6786         ndr->depth++;
6787         if (r->provider) {
6788                 ndr_print_string(ndr, "provider", r->provider);
6789         }
6790         ndr->depth--;
6791         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6792         ndr->depth++;
6793         if (r->print_processor) {
6794                 ndr_print_string(ndr, "print_processor", r->print_processor);
6795         }
6796         ndr->depth--;
6797         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
6798         ndr->depth++;
6799         if (r->vendor_setup) {
6800                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
6801         }
6802         ndr->depth--;
6803         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);
6804         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
6805         ndr->depth++;
6806         if (r->color_profiles) {
6807                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
6808         }
6809         ndr->depth--;
6810         ndr_print_ptr(ndr, "inf_path", r->inf_path);
6811         ndr->depth++;
6812         if (r->inf_path) {
6813                 ndr_print_string(ndr, "inf_path", r->inf_path);
6814         }
6815         ndr->depth--;
6816         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
6817         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);
6818         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6819         ndr->depth++;
6820         if (r->core_driver_dependencies) {
6821                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6822         }
6823         ndr->depth--;
6824         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
6825         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
6826         ndr->depth--;
6827 }
6828
6829 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
6830 {
6831         if (ndr_flags & NDR_SCALARS) {
6832                 int level = ndr_push_get_switch_value(ndr, r);
6833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6834                 switch (level) {
6835                         case 1: {
6836                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6837                         break; }
6838
6839                         case 2: {
6840                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6841                         break; }
6842
6843                         case 3: {
6844                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6845                         break; }
6846
6847                         case 4: {
6848                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6849                         break; }
6850
6851                         case 6: {
6852                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6853                         break; }
6854
6855                         case 8: {
6856                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6857                         break; }
6858
6859                         default:
6860                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6861                 }
6862         }
6863         if (ndr_flags & NDR_BUFFERS) {
6864                 int level = ndr_push_get_switch_value(ndr, r);
6865                 switch (level) {
6866                         case 1:
6867                                 if (r->info1) {
6868                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6869                                 }
6870                         break;
6871
6872                         case 2:
6873                                 if (r->info2) {
6874                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6875                                 }
6876                         break;
6877
6878                         case 3:
6879                                 if (r->info3) {
6880                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6881                                 }
6882                         break;
6883
6884                         case 4:
6885                                 if (r->info4) {
6886                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6887                                 }
6888                         break;
6889
6890                         case 6:
6891                                 if (r->info6) {
6892                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
6893                                 }
6894                         break;
6895
6896                         case 8:
6897                                 if (r->info8) {
6898                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6899                                 }
6900                         break;
6901
6902                         default:
6903                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6904                 }
6905         }
6906         return NDR_ERR_SUCCESS;
6907 }
6908
6909 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
6910 {
6911         int level;
6912         uint32_t _level;
6913         TALLOC_CTX *_mem_save_info1_0;
6914         TALLOC_CTX *_mem_save_info2_0;
6915         TALLOC_CTX *_mem_save_info3_0;
6916         TALLOC_CTX *_mem_save_info4_0;
6917         TALLOC_CTX *_mem_save_info6_0;
6918         TALLOC_CTX *_mem_save_info8_0;
6919         level = ndr_pull_get_switch_value(ndr, r);
6920         if (ndr_flags & NDR_SCALARS) {
6921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6922                 if (_level != level) {
6923                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6924                 }
6925                 switch (level) {
6926                         case 1: {
6927                                 uint32_t _ptr_info1;
6928                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6929                                 if (_ptr_info1) {
6930                                         NDR_PULL_ALLOC(ndr, r->info1);
6931                                 } else {
6932                                         r->info1 = NULL;
6933                                 }
6934                         break; }
6935
6936                         case 2: {
6937                                 uint32_t _ptr_info2;
6938                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6939                                 if (_ptr_info2) {
6940                                         NDR_PULL_ALLOC(ndr, r->info2);
6941                                 } else {
6942                                         r->info2 = NULL;
6943                                 }
6944                         break; }
6945
6946                         case 3: {
6947                                 uint32_t _ptr_info3;
6948                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6949                                 if (_ptr_info3) {
6950                                         NDR_PULL_ALLOC(ndr, r->info3);
6951                                 } else {
6952                                         r->info3 = NULL;
6953                                 }
6954                         break; }
6955
6956                         case 4: {
6957                                 uint32_t _ptr_info4;
6958                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6959                                 if (_ptr_info4) {
6960                                         NDR_PULL_ALLOC(ndr, r->info4);
6961                                 } else {
6962                                         r->info4 = NULL;
6963                                 }
6964                         break; }
6965
6966                         case 6: {
6967                                 uint32_t _ptr_info6;
6968                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
6969                                 if (_ptr_info6) {
6970                                         NDR_PULL_ALLOC(ndr, r->info6);
6971                                 } else {
6972                                         r->info6 = NULL;
6973                                 }
6974                         break; }
6975
6976                         case 8: {
6977                                 uint32_t _ptr_info8;
6978                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
6979                                 if (_ptr_info8) {
6980                                         NDR_PULL_ALLOC(ndr, r->info8);
6981                                 } else {
6982                                         r->info8 = NULL;
6983                                 }
6984                         break; }
6985
6986                         default:
6987                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6988                 }
6989         }
6990         if (ndr_flags & NDR_BUFFERS) {
6991                 switch (level) {
6992                         case 1:
6993                                 if (r->info1) {
6994                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6995                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6996                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6997                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6998                                 }
6999                         break;
7000
7001                         case 2:
7002                                 if (r->info2) {
7003                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7004                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7005                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7006                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7007                                 }
7008                         break;
7009
7010                         case 3:
7011                                 if (r->info3) {
7012                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7013                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7014                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
7015                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7016                                 }
7017                         break;
7018
7019                         case 4:
7020                                 if (r->info4) {
7021                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7022                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7023                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7024                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7025                                 }
7026                         break;
7027
7028                         case 6:
7029                                 if (r->info6) {
7030                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7031                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7032                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
7033                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7034                                 }
7035                         break;
7036
7037                         case 8:
7038                                 if (r->info8) {
7039                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7040                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7041                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7042                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7043                                 }
7044                         break;
7045
7046                         default:
7047                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7048                 }
7049         }
7050         return NDR_ERR_SUCCESS;
7051 }
7052
7053 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
7054 {
7055         int level;
7056         level = ndr_print_get_switch_value(ndr, r);
7057         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
7058         switch (level) {
7059                 case 1:
7060                         ndr_print_ptr(ndr, "info1", r->info1);
7061                         ndr->depth++;
7062                         if (r->info1) {
7063                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
7064                         }
7065                         ndr->depth--;
7066                 break;
7067
7068                 case 2:
7069                         ndr_print_ptr(ndr, "info2", r->info2);
7070                         ndr->depth++;
7071                         if (r->info2) {
7072                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
7073                         }
7074                         ndr->depth--;
7075                 break;
7076
7077                 case 3:
7078                         ndr_print_ptr(ndr, "info3", r->info3);
7079                         ndr->depth++;
7080                         if (r->info3) {
7081                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
7082                         }
7083                         ndr->depth--;
7084                 break;
7085
7086                 case 4:
7087                         ndr_print_ptr(ndr, "info4", r->info4);
7088                         ndr->depth++;
7089                         if (r->info4) {
7090                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
7091                         }
7092                         ndr->depth--;
7093                 break;
7094
7095                 case 6:
7096                         ndr_print_ptr(ndr, "info6", r->info6);
7097                         ndr->depth++;
7098                         if (r->info6) {
7099                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
7100                         }
7101                         ndr->depth--;
7102                 break;
7103
7104                 case 8:
7105                         ndr_print_ptr(ndr, "info8", r->info8);
7106                         ndr->depth++;
7107                         if (r->info8) {
7108                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
7109                         }
7110                         ndr->depth--;
7111                 break;
7112
7113                 default:
7114                         ndr_print_bad_level(ndr, name, level);
7115         }
7116 }
7117
7118 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
7119 {
7120         if (ndr_flags & NDR_SCALARS) {
7121                 NDR_CHECK(ndr_push_align(ndr, 4));
7122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7123                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7124                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7125         }
7126         if (ndr_flags & NDR_BUFFERS) {
7127                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7128         }
7129         return NDR_ERR_SUCCESS;
7130 }
7131
7132 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
7133 {
7134         if (ndr_flags & NDR_SCALARS) {
7135                 NDR_CHECK(ndr_pull_align(ndr, 4));
7136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7137                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7138                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7139         }
7140         if (ndr_flags & NDR_BUFFERS) {
7141                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7142         }
7143         return NDR_ERR_SUCCESS;
7144 }
7145
7146 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
7147 {
7148         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
7149         ndr->depth++;
7150         ndr_print_uint32(ndr, "level", r->level);
7151         ndr_print_set_switch_value(ndr, &r->info, r->level);
7152         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
7153         ndr->depth--;
7154 }
7155
7156 static enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
7157 {
7158         if (ndr_flags & NDR_SCALARS) {
7159                 NDR_CHECK(ndr_push_align(ndr, 4));
7160                 {
7161                         uint32_t _flags_save_string = ndr->flags;
7162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7163                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7164                         ndr->flags = _flags_save_string;
7165                 }
7166         }
7167         if (ndr_flags & NDR_BUFFERS) {
7168                 {
7169                         uint32_t _flags_save_string = ndr->flags;
7170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7171                         if (r->driver_name) {
7172                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7173                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7174                         }
7175                         ndr->flags = _flags_save_string;
7176                 }
7177         }
7178         return NDR_ERR_SUCCESS;
7179 }
7180
7181 static enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
7182 {
7183         uint32_t _ptr_driver_name;
7184         TALLOC_CTX *_mem_save_driver_name_0;
7185         if (ndr_flags & NDR_SCALARS) {
7186                 NDR_CHECK(ndr_pull_align(ndr, 4));
7187                 {
7188                         uint32_t _flags_save_string = ndr->flags;
7189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7191                         if (_ptr_driver_name) {
7192                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7194                         } else {
7195                                 r->driver_name = NULL;
7196                         }
7197                         ndr->flags = _flags_save_string;
7198                 }
7199         }
7200         if (ndr_flags & NDR_BUFFERS) {
7201                 {
7202                         uint32_t _flags_save_string = ndr->flags;
7203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7204                         if (r->driver_name) {
7205                                 uint32_t _relative_save_offset;
7206                                 _relative_save_offset = ndr->offset;
7207                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7208                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7209                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7210                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7211                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7212                                 ndr->offset = _relative_save_offset;
7213                         }
7214                         ndr->flags = _flags_save_string;
7215                 }
7216         }
7217         return NDR_ERR_SUCCESS;
7218 }
7219
7220 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
7221 {
7222         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
7223         ndr->depth++;
7224         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7225         ndr->depth++;
7226         if (r->driver_name) {
7227                 ndr_print_string(ndr, "driver_name", r->driver_name);
7228         }
7229         ndr->depth--;
7230         ndr->depth--;
7231 }
7232
7233 static 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 static 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 static enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
7514 {
7515         if (ndr_flags & NDR_SCALARS) {
7516                 NDR_CHECK(ndr_push_align(ndr, 4));
7517                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7518                 {
7519                         uint32_t _flags_save_string = ndr->flags;
7520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7521                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7522                         ndr->flags = _flags_save_string;
7523                 }
7524                 {
7525                         uint32_t _flags_save_string = ndr->flags;
7526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7527                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7528                         ndr->flags = _flags_save_string;
7529                 }
7530                 {
7531                         uint32_t _flags_save_string = ndr->flags;
7532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7533                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7534                         ndr->flags = _flags_save_string;
7535                 }
7536                 {
7537                         uint32_t _flags_save_string = ndr->flags;
7538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7539                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7540                         ndr->flags = _flags_save_string;
7541                 }
7542                 {
7543                         uint32_t _flags_save_string = ndr->flags;
7544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7545                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7546                         ndr->flags = _flags_save_string;
7547                 }
7548                 {
7549                         uint32_t _flags_save_string = ndr->flags;
7550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7551                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
7552                         ndr->flags = _flags_save_string;
7553                 }
7554                 {
7555                         uint32_t _flags_save_string_array = ndr->flags;
7556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7557                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
7558                         ndr->flags = _flags_save_string_array;
7559                 }
7560                 {
7561                         uint32_t _flags_save_string = ndr->flags;
7562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7563                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7564                         ndr->flags = _flags_save_string;
7565                 }
7566                 {
7567                         uint32_t _flags_save_string = ndr->flags;
7568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
7570                         ndr->flags = _flags_save_string;
7571                 }
7572         }
7573         if (ndr_flags & NDR_BUFFERS) {
7574                 {
7575                         uint32_t _flags_save_string = ndr->flags;
7576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7577                         if (r->driver_name) {
7578                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7580                         }
7581                         ndr->flags = _flags_save_string;
7582                 }
7583                 {
7584                         uint32_t _flags_save_string = ndr->flags;
7585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7586                         if (r->architecture) {
7587                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7589                         }
7590                         ndr->flags = _flags_save_string;
7591                 }
7592                 {
7593                         uint32_t _flags_save_string = ndr->flags;
7594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7595                         if (r->driver_path) {
7596                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7597                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7598                         }
7599                         ndr->flags = _flags_save_string;
7600                 }
7601                 {
7602                         uint32_t _flags_save_string = ndr->flags;
7603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7604                         if (r->data_file) {
7605                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7606                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7607                         }
7608                         ndr->flags = _flags_save_string;
7609                 }
7610                 {
7611                         uint32_t _flags_save_string = ndr->flags;
7612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7613                         if (r->config_file) {
7614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7616                         }
7617                         ndr->flags = _flags_save_string;
7618                 }
7619                 {
7620                         uint32_t _flags_save_string = ndr->flags;
7621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7622                         if (r->help_file) {
7623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
7624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
7625                         }
7626                         ndr->flags = _flags_save_string;
7627                 }
7628                 {
7629                         uint32_t _flags_save_string_array = ndr->flags;
7630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7631                         if (r->dependent_files) {
7632                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
7633                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
7634                         }
7635                         ndr->flags = _flags_save_string_array;
7636                 }
7637                 {
7638                         uint32_t _flags_save_string = ndr->flags;
7639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7640                         if (r->monitor_name) {
7641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7643                         }
7644                         ndr->flags = _flags_save_string;
7645                 }
7646                 {
7647                         uint32_t _flags_save_string = ndr->flags;
7648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7649                         if (r->default_datatype) {
7650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
7651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
7652                         }
7653                         ndr->flags = _flags_save_string;
7654                 }
7655         }
7656         return NDR_ERR_SUCCESS;
7657 }
7658
7659 static enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
7660 {
7661         uint32_t _ptr_driver_name;
7662         TALLOC_CTX *_mem_save_driver_name_0;
7663         uint32_t _ptr_architecture;
7664         TALLOC_CTX *_mem_save_architecture_0;
7665         uint32_t _ptr_driver_path;
7666         TALLOC_CTX *_mem_save_driver_path_0;
7667         uint32_t _ptr_data_file;
7668         TALLOC_CTX *_mem_save_data_file_0;
7669         uint32_t _ptr_config_file;
7670         TALLOC_CTX *_mem_save_config_file_0;
7671         uint32_t _ptr_help_file;
7672         TALLOC_CTX *_mem_save_help_file_0;
7673         uint32_t _ptr_dependent_files;
7674         TALLOC_CTX *_mem_save_dependent_files_0;
7675         uint32_t _ptr_monitor_name;
7676         TALLOC_CTX *_mem_save_monitor_name_0;
7677         uint32_t _ptr_default_datatype;
7678         TALLOC_CTX *_mem_save_default_datatype_0;
7679         if (ndr_flags & NDR_SCALARS) {
7680                 NDR_CHECK(ndr_pull_align(ndr, 4));
7681                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7682                 {
7683                         uint32_t _flags_save_string = ndr->flags;
7684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7685                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7686                         if (_ptr_driver_name) {
7687                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7688                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7689                         } else {
7690                                 r->driver_name = NULL;
7691                         }
7692                         ndr->flags = _flags_save_string;
7693                 }
7694                 {
7695                         uint32_t _flags_save_string = ndr->flags;
7696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7697                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7698                         if (_ptr_architecture) {
7699                                 NDR_PULL_ALLOC(ndr, r->architecture);
7700                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7701                         } else {
7702                                 r->architecture = NULL;
7703                         }
7704                         ndr->flags = _flags_save_string;
7705                 }
7706                 {
7707                         uint32_t _flags_save_string = ndr->flags;
7708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7709                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7710                         if (_ptr_driver_path) {
7711                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7712                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7713                         } else {
7714                                 r->driver_path = NULL;
7715                         }
7716                         ndr->flags = _flags_save_string;
7717                 }
7718                 {
7719                         uint32_t _flags_save_string = ndr->flags;
7720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7721                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7722                         if (_ptr_data_file) {
7723                                 NDR_PULL_ALLOC(ndr, r->data_file);
7724                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7725                         } else {
7726                                 r->data_file = NULL;
7727                         }
7728                         ndr->flags = _flags_save_string;
7729                 }
7730                 {
7731                         uint32_t _flags_save_string = ndr->flags;
7732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7733                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7734                         if (_ptr_config_file) {
7735                                 NDR_PULL_ALLOC(ndr, r->config_file);
7736                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7737                         } else {
7738                                 r->config_file = NULL;
7739                         }
7740                         ndr->flags = _flags_save_string;
7741                 }
7742                 {
7743                         uint32_t _flags_save_string = ndr->flags;
7744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7745                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7746                         if (_ptr_help_file) {
7747                                 NDR_PULL_ALLOC(ndr, r->help_file);
7748                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7749                         } else {
7750                                 r->help_file = NULL;
7751                         }
7752                         ndr->flags = _flags_save_string;
7753                 }
7754                 {
7755                         uint32_t _flags_save_string_array = ndr->flags;
7756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7757                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7758                         if (_ptr_dependent_files) {
7759                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7760                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7761                         } else {
7762                                 r->dependent_files = NULL;
7763                         }
7764                         ndr->flags = _flags_save_string_array;
7765                 }
7766                 {
7767                         uint32_t _flags_save_string = ndr->flags;
7768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7769                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7770                         if (_ptr_monitor_name) {
7771                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7772                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7773                         } else {
7774                                 r->monitor_name = NULL;
7775                         }
7776                         ndr->flags = _flags_save_string;
7777                 }
7778                 {
7779                         uint32_t _flags_save_string = ndr->flags;
7780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7781                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7782                         if (_ptr_default_datatype) {
7783                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7784                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7785                         } else {
7786                                 r->default_datatype = NULL;
7787                         }
7788                         ndr->flags = _flags_save_string;
7789                 }
7790         }
7791         if (ndr_flags & NDR_BUFFERS) {
7792                 {
7793                         uint32_t _flags_save_string = ndr->flags;
7794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7795                         if (r->driver_name) {
7796                                 uint32_t _relative_save_offset;
7797                                 _relative_save_offset = ndr->offset;
7798                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7799                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7800                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7801                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7802                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7803                                 ndr->offset = _relative_save_offset;
7804                         }
7805                         ndr->flags = _flags_save_string;
7806                 }
7807                 {
7808                         uint32_t _flags_save_string = ndr->flags;
7809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7810                         if (r->architecture) {
7811                                 uint32_t _relative_save_offset;
7812                                 _relative_save_offset = ndr->offset;
7813                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7814                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7815                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7816                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7817                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7818                                 ndr->offset = _relative_save_offset;
7819                         }
7820                         ndr->flags = _flags_save_string;
7821                 }
7822                 {
7823                         uint32_t _flags_save_string = ndr->flags;
7824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7825                         if (r->driver_path) {
7826                                 uint32_t _relative_save_offset;
7827                                 _relative_save_offset = ndr->offset;
7828                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7829                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7830                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7831                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7832                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7833                                 ndr->offset = _relative_save_offset;
7834                         }
7835                         ndr->flags = _flags_save_string;
7836                 }
7837                 {
7838                         uint32_t _flags_save_string = ndr->flags;
7839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7840                         if (r->data_file) {
7841                                 uint32_t _relative_save_offset;
7842                                 _relative_save_offset = ndr->offset;
7843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7844                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7845                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7848                                 ndr->offset = _relative_save_offset;
7849                         }
7850                         ndr->flags = _flags_save_string;
7851                 }
7852                 {
7853                         uint32_t _flags_save_string = ndr->flags;
7854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7855                         if (r->config_file) {
7856                                 uint32_t _relative_save_offset;
7857                                 _relative_save_offset = ndr->offset;
7858                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7859                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7860                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7861                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7862                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7863                                 ndr->offset = _relative_save_offset;
7864                         }
7865                         ndr->flags = _flags_save_string;
7866                 }
7867                 {
7868                         uint32_t _flags_save_string = ndr->flags;
7869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7870                         if (r->help_file) {
7871                                 uint32_t _relative_save_offset;
7872                                 _relative_save_offset = ndr->offset;
7873                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7874                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7875                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7876                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7877                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7878                                 ndr->offset = _relative_save_offset;
7879                         }
7880                         ndr->flags = _flags_save_string;
7881                 }
7882                 {
7883                         uint32_t _flags_save_string_array = ndr->flags;
7884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7885                         if (r->dependent_files) {
7886                                 uint32_t _relative_save_offset;
7887                                 _relative_save_offset = ndr->offset;
7888                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7889                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7890                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7891                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7892                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7893                                 ndr->offset = _relative_save_offset;
7894                         }
7895                         ndr->flags = _flags_save_string_array;
7896                 }
7897                 {
7898                         uint32_t _flags_save_string = ndr->flags;
7899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7900                         if (r->monitor_name) {
7901                                 uint32_t _relative_save_offset;
7902                                 _relative_save_offset = ndr->offset;
7903                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7904                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7905                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7906                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7907                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7908                                 ndr->offset = _relative_save_offset;
7909                         }
7910                         ndr->flags = _flags_save_string;
7911                 }
7912                 {
7913                         uint32_t _flags_save_string = ndr->flags;
7914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7915                         if (r->default_datatype) {
7916                                 uint32_t _relative_save_offset;
7917                                 _relative_save_offset = ndr->offset;
7918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7919                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7923                                 ndr->offset = _relative_save_offset;
7924                         }
7925                         ndr->flags = _flags_save_string;
7926                 }
7927         }
7928         return NDR_ERR_SUCCESS;
7929 }
7930
7931 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
7932 {
7933         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
7934         ndr->depth++;
7935         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7936         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7937         ndr->depth++;
7938         if (r->driver_name) {
7939                 ndr_print_string(ndr, "driver_name", r->driver_name);
7940         }
7941         ndr->depth--;
7942         ndr_print_ptr(ndr, "architecture", r->architecture);
7943         ndr->depth++;
7944         if (r->architecture) {
7945                 ndr_print_string(ndr, "architecture", r->architecture);
7946         }
7947         ndr->depth--;
7948         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7949         ndr->depth++;
7950         if (r->driver_path) {
7951                 ndr_print_string(ndr, "driver_path", r->driver_path);
7952         }
7953         ndr->depth--;
7954         ndr_print_ptr(ndr, "data_file", r->data_file);
7955         ndr->depth++;
7956         if (r->data_file) {
7957                 ndr_print_string(ndr, "data_file", r->data_file);
7958         }
7959         ndr->depth--;
7960         ndr_print_ptr(ndr, "config_file", r->config_file);
7961         ndr->depth++;
7962         if (r->config_file) {
7963                 ndr_print_string(ndr, "config_file", r->config_file);
7964         }
7965         ndr->depth--;
7966         ndr_print_ptr(ndr, "help_file", r->help_file);
7967         ndr->depth++;
7968         if (r->help_file) {
7969                 ndr_print_string(ndr, "help_file", r->help_file);
7970         }
7971         ndr->depth--;
7972         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7973         ndr->depth++;
7974         if (r->dependent_files) {
7975                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7976         }
7977         ndr->depth--;
7978         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7979         ndr->depth++;
7980         if (r->monitor_name) {
7981                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7982         }
7983         ndr->depth--;
7984         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7985         ndr->depth++;
7986         if (r->default_datatype) {
7987                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7988         }
7989         ndr->depth--;
7990         ndr->depth--;
7991 }
7992
7993 static enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
7994 {
7995         if (ndr_flags & NDR_SCALARS) {
7996                 NDR_CHECK(ndr_push_align(ndr, 4));
7997                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7998                 {
7999                         uint32_t _flags_save_string = ndr->flags;
8000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8002                         ndr->flags = _flags_save_string;
8003                 }
8004                 {
8005                         uint32_t _flags_save_string = ndr->flags;
8006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8008                         ndr->flags = _flags_save_string;
8009                 }
8010                 {
8011                         uint32_t _flags_save_string = ndr->flags;
8012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8014                         ndr->flags = _flags_save_string;
8015                 }
8016                 {
8017                         uint32_t _flags_save_string = ndr->flags;
8018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8020                         ndr->flags = _flags_save_string;
8021                 }
8022                 {
8023                         uint32_t _flags_save_string = ndr->flags;
8024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8026                         ndr->flags = _flags_save_string;
8027                 }
8028                 {
8029                         uint32_t _flags_save_string = ndr->flags;
8030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8031                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8032                         ndr->flags = _flags_save_string;
8033                 }
8034                 {
8035                         uint32_t _flags_save_string_array = ndr->flags;
8036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8037                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8038                         ndr->flags = _flags_save_string_array;
8039                 }
8040                 {
8041                         uint32_t _flags_save_string = ndr->flags;
8042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8043                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8044                         ndr->flags = _flags_save_string;
8045                 }
8046                 {
8047                         uint32_t _flags_save_string = ndr->flags;
8048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8049                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8050                         ndr->flags = _flags_save_string;
8051                 }
8052                 {
8053                         uint32_t _flags_save_string_array = ndr->flags;
8054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8055                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8056                         ndr->flags = _flags_save_string_array;
8057                 }
8058         }
8059         if (ndr_flags & NDR_BUFFERS) {
8060                 {
8061                         uint32_t _flags_save_string = ndr->flags;
8062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8063                         if (r->driver_name) {
8064                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8065                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8066                         }
8067                         ndr->flags = _flags_save_string;
8068                 }
8069                 {
8070                         uint32_t _flags_save_string = ndr->flags;
8071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8072                         if (r->architecture) {
8073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8075                         }
8076                         ndr->flags = _flags_save_string;
8077                 }
8078                 {
8079                         uint32_t _flags_save_string = ndr->flags;
8080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8081                         if (r->driver_path) {
8082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8084                         }
8085                         ndr->flags = _flags_save_string;
8086                 }
8087                 {
8088                         uint32_t _flags_save_string = ndr->flags;
8089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8090                         if (r->data_file) {
8091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8093                         }
8094                         ndr->flags = _flags_save_string;
8095                 }
8096                 {
8097                         uint32_t _flags_save_string = ndr->flags;
8098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8099                         if (r->config_file) {
8100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8102                         }
8103                         ndr->flags = _flags_save_string;
8104                 }
8105                 {
8106                         uint32_t _flags_save_string = ndr->flags;
8107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8108                         if (r->help_file) {
8109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8111                         }
8112                         ndr->flags = _flags_save_string;
8113                 }
8114                 {
8115                         uint32_t _flags_save_string_array = ndr->flags;
8116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8117                         if (r->dependent_files) {
8118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8119                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8120                         }
8121                         ndr->flags = _flags_save_string_array;
8122                 }
8123                 {
8124                         uint32_t _flags_save_string = ndr->flags;
8125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8126                         if (r->monitor_name) {
8127                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8128                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8129                         }
8130                         ndr->flags = _flags_save_string;
8131                 }
8132                 {
8133                         uint32_t _flags_save_string = ndr->flags;
8134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8135                         if (r->default_datatype) {
8136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8138                         }
8139                         ndr->flags = _flags_save_string;
8140                 }
8141                 {
8142                         uint32_t _flags_save_string_array = ndr->flags;
8143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8144                         if (r->previous_names) {
8145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8146                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8147                         }
8148                         ndr->flags = _flags_save_string_array;
8149                 }
8150         }
8151         return NDR_ERR_SUCCESS;
8152 }
8153
8154 static enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
8155 {
8156         uint32_t _ptr_driver_name;
8157         TALLOC_CTX *_mem_save_driver_name_0;
8158         uint32_t _ptr_architecture;
8159         TALLOC_CTX *_mem_save_architecture_0;
8160         uint32_t _ptr_driver_path;
8161         TALLOC_CTX *_mem_save_driver_path_0;
8162         uint32_t _ptr_data_file;
8163         TALLOC_CTX *_mem_save_data_file_0;
8164         uint32_t _ptr_config_file;
8165         TALLOC_CTX *_mem_save_config_file_0;
8166         uint32_t _ptr_help_file;
8167         TALLOC_CTX *_mem_save_help_file_0;
8168         uint32_t _ptr_dependent_files;
8169         TALLOC_CTX *_mem_save_dependent_files_0;
8170         uint32_t _ptr_monitor_name;
8171         TALLOC_CTX *_mem_save_monitor_name_0;
8172         uint32_t _ptr_default_datatype;
8173         TALLOC_CTX *_mem_save_default_datatype_0;
8174         uint32_t _ptr_previous_names;
8175         TALLOC_CTX *_mem_save_previous_names_0;
8176         if (ndr_flags & NDR_SCALARS) {
8177                 NDR_CHECK(ndr_pull_align(ndr, 4));
8178                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8179                 {
8180                         uint32_t _flags_save_string = ndr->flags;
8181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8182                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8183                         if (_ptr_driver_name) {
8184                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8185                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8186                         } else {
8187                                 r->driver_name = NULL;
8188                         }
8189                         ndr->flags = _flags_save_string;
8190                 }
8191                 {
8192                         uint32_t _flags_save_string = ndr->flags;
8193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8194                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8195                         if (_ptr_architecture) {
8196                                 NDR_PULL_ALLOC(ndr, r->architecture);
8197                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8198                         } else {
8199                                 r->architecture = NULL;
8200                         }
8201                         ndr->flags = _flags_save_string;
8202                 }
8203                 {
8204                         uint32_t _flags_save_string = ndr->flags;
8205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8206                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8207                         if (_ptr_driver_path) {
8208                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8209                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8210                         } else {
8211                                 r->driver_path = NULL;
8212                         }
8213                         ndr->flags = _flags_save_string;
8214                 }
8215                 {
8216                         uint32_t _flags_save_string = ndr->flags;
8217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8218                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8219                         if (_ptr_data_file) {
8220                                 NDR_PULL_ALLOC(ndr, r->data_file);
8221                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8222                         } else {
8223                                 r->data_file = NULL;
8224                         }
8225                         ndr->flags = _flags_save_string;
8226                 }
8227                 {
8228                         uint32_t _flags_save_string = ndr->flags;
8229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8230                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8231                         if (_ptr_config_file) {
8232                                 NDR_PULL_ALLOC(ndr, r->config_file);
8233                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8234                         } else {
8235                                 r->config_file = NULL;
8236                         }
8237                         ndr->flags = _flags_save_string;
8238                 }
8239                 {
8240                         uint32_t _flags_save_string = ndr->flags;
8241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8242                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8243                         if (_ptr_help_file) {
8244                                 NDR_PULL_ALLOC(ndr, r->help_file);
8245                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
8246                         } else {
8247                                 r->help_file = NULL;
8248                         }
8249                         ndr->flags = _flags_save_string;
8250                 }
8251                 {
8252                         uint32_t _flags_save_string_array = ndr->flags;
8253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8254                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8255                         if (_ptr_dependent_files) {
8256                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
8257                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
8258                         } else {
8259                                 r->dependent_files = NULL;
8260                         }
8261                         ndr->flags = _flags_save_string_array;
8262                 }
8263                 {
8264                         uint32_t _flags_save_string = ndr->flags;
8265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8266                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8267                         if (_ptr_monitor_name) {
8268                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
8269                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
8270                         } else {
8271                                 r->monitor_name = NULL;
8272                         }
8273                         ndr->flags = _flags_save_string;
8274                 }
8275                 {
8276                         uint32_t _flags_save_string = ndr->flags;
8277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8278                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8279                         if (_ptr_default_datatype) {
8280                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
8281                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
8282                         } else {
8283                                 r->default_datatype = NULL;
8284                         }
8285                         ndr->flags = _flags_save_string;
8286                 }
8287                 {
8288                         uint32_t _flags_save_string_array = ndr->flags;
8289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8290                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8291                         if (_ptr_previous_names) {
8292                                 NDR_PULL_ALLOC(ndr, r->previous_names);
8293                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
8294                         } else {
8295                                 r->previous_names = NULL;
8296                         }
8297                         ndr->flags = _flags_save_string_array;
8298                 }
8299         }
8300         if (ndr_flags & NDR_BUFFERS) {
8301                 {
8302                         uint32_t _flags_save_string = ndr->flags;
8303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8304                         if (r->driver_name) {
8305                                 uint32_t _relative_save_offset;
8306                                 _relative_save_offset = ndr->offset;
8307                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8308                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8309                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8310                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8311                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8312                                 ndr->offset = _relative_save_offset;
8313                         }
8314                         ndr->flags = _flags_save_string;
8315                 }
8316                 {
8317                         uint32_t _flags_save_string = ndr->flags;
8318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8319                         if (r->architecture) {
8320                                 uint32_t _relative_save_offset;
8321                                 _relative_save_offset = ndr->offset;
8322                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8323                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8324                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8325                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8326                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8327                                 ndr->offset = _relative_save_offset;
8328                         }
8329                         ndr->flags = _flags_save_string;
8330                 }
8331                 {
8332                         uint32_t _flags_save_string = ndr->flags;
8333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8334                         if (r->driver_path) {
8335                                 uint32_t _relative_save_offset;
8336                                 _relative_save_offset = ndr->offset;
8337                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8338                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8339                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8340                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8341                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8342                                 ndr->offset = _relative_save_offset;
8343                         }
8344                         ndr->flags = _flags_save_string;
8345                 }
8346                 {
8347                         uint32_t _flags_save_string = ndr->flags;
8348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8349                         if (r->data_file) {
8350                                 uint32_t _relative_save_offset;
8351                                 _relative_save_offset = ndr->offset;
8352                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8353                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8354                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8355                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8356                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8357                                 ndr->offset = _relative_save_offset;
8358                         }
8359                         ndr->flags = _flags_save_string;
8360                 }
8361                 {
8362                         uint32_t _flags_save_string = ndr->flags;
8363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8364                         if (r->config_file) {
8365                                 uint32_t _relative_save_offset;
8366                                 _relative_save_offset = ndr->offset;
8367                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8368                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8369                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8370                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8371                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8372                                 ndr->offset = _relative_save_offset;
8373                         }
8374                         ndr->flags = _flags_save_string;
8375                 }
8376                 {
8377                         uint32_t _flags_save_string = ndr->flags;
8378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8379                         if (r->help_file) {
8380                                 uint32_t _relative_save_offset;
8381                                 _relative_save_offset = ndr->offset;
8382                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
8383                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8384                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8385                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
8386                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8387                                 ndr->offset = _relative_save_offset;
8388                         }
8389                         ndr->flags = _flags_save_string;
8390                 }
8391                 {
8392                         uint32_t _flags_save_string_array = ndr->flags;
8393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8394                         if (r->dependent_files) {
8395                                 uint32_t _relative_save_offset;
8396                                 _relative_save_offset = ndr->offset;
8397                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
8398                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8399                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8400                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
8401                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8402                                 ndr->offset = _relative_save_offset;
8403                         }
8404                         ndr->flags = _flags_save_string_array;
8405                 }
8406                 {
8407                         uint32_t _flags_save_string = ndr->flags;
8408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8409                         if (r->monitor_name) {
8410                                 uint32_t _relative_save_offset;
8411                                 _relative_save_offset = ndr->offset;
8412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
8413                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8414                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
8416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8417                                 ndr->offset = _relative_save_offset;
8418                         }
8419                         ndr->flags = _flags_save_string;
8420                 }
8421                 {
8422                         uint32_t _flags_save_string = ndr->flags;
8423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8424                         if (r->default_datatype) {
8425                                 uint32_t _relative_save_offset;
8426                                 _relative_save_offset = ndr->offset;
8427                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
8428                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8429                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8430                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
8431                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8432                                 ndr->offset = _relative_save_offset;
8433                         }
8434                         ndr->flags = _flags_save_string;
8435                 }
8436                 {
8437                         uint32_t _flags_save_string_array = ndr->flags;
8438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8439                         if (r->previous_names) {
8440                                 uint32_t _relative_save_offset;
8441                                 _relative_save_offset = ndr->offset;
8442                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
8443                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8444                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8445                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
8446                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8447                                 ndr->offset = _relative_save_offset;
8448                         }
8449                         ndr->flags = _flags_save_string_array;
8450                 }
8451         }
8452         return NDR_ERR_SUCCESS;
8453 }
8454
8455 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
8456 {
8457         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
8458         ndr->depth++;
8459         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8460         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8461         ndr->depth++;
8462         if (r->driver_name) {
8463                 ndr_print_string(ndr, "driver_name", r->driver_name);
8464         }
8465         ndr->depth--;
8466         ndr_print_ptr(ndr, "architecture", r->architecture);
8467         ndr->depth++;
8468         if (r->architecture) {
8469                 ndr_print_string(ndr, "architecture", r->architecture);
8470         }
8471         ndr->depth--;
8472         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8473         ndr->depth++;
8474         if (r->driver_path) {
8475                 ndr_print_string(ndr, "driver_path", r->driver_path);
8476         }
8477         ndr->depth--;
8478         ndr_print_ptr(ndr, "data_file", r->data_file);
8479         ndr->depth++;
8480         if (r->data_file) {
8481                 ndr_print_string(ndr, "data_file", r->data_file);
8482         }
8483         ndr->depth--;
8484         ndr_print_ptr(ndr, "config_file", r->config_file);
8485         ndr->depth++;
8486         if (r->config_file) {
8487                 ndr_print_string(ndr, "config_file", r->config_file);
8488         }
8489         ndr->depth--;
8490         ndr_print_ptr(ndr, "help_file", r->help_file);
8491         ndr->depth++;
8492         if (r->help_file) {
8493                 ndr_print_string(ndr, "help_file", r->help_file);
8494         }
8495         ndr->depth--;
8496         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8497         ndr->depth++;
8498         if (r->dependent_files) {
8499                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
8500         }
8501         ndr->depth--;
8502         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8503         ndr->depth++;
8504         if (r->monitor_name) {
8505                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8506         }
8507         ndr->depth--;
8508         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8509         ndr->depth++;
8510         if (r->default_datatype) {
8511                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8512         }
8513         ndr->depth--;
8514         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8515         ndr->depth++;
8516         if (r->previous_names) {
8517                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
8518         }
8519         ndr->depth--;
8520         ndr->depth--;
8521 }
8522
8523 static enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
8524 {
8525         if (ndr_flags & NDR_SCALARS) {
8526                 NDR_CHECK(ndr_push_align(ndr, 4));
8527                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8528                 {
8529                         uint32_t _flags_save_string = ndr->flags;
8530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8532                         ndr->flags = _flags_save_string;
8533                 }
8534                 {
8535                         uint32_t _flags_save_string = ndr->flags;
8536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8538                         ndr->flags = _flags_save_string;
8539                 }
8540                 {
8541                         uint32_t _flags_save_string = ndr->flags;
8542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8544                         ndr->flags = _flags_save_string;
8545                 }
8546                 {
8547                         uint32_t _flags_save_string = ndr->flags;
8548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8550                         ndr->flags = _flags_save_string;
8551                 }
8552                 {
8553                         uint32_t _flags_save_string = ndr->flags;
8554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8556                         ndr->flags = _flags_save_string;
8557                 }
8558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
8559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
8560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
8561         }
8562         if (ndr_flags & NDR_BUFFERS) {
8563                 {
8564                         uint32_t _flags_save_string = ndr->flags;
8565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8566                         if (r->driver_name) {
8567                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8568                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8569                         }
8570                         ndr->flags = _flags_save_string;
8571                 }
8572                 {
8573                         uint32_t _flags_save_string = ndr->flags;
8574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8575                         if (r->architecture) {
8576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8578                         }
8579                         ndr->flags = _flags_save_string;
8580                 }
8581                 {
8582                         uint32_t _flags_save_string = ndr->flags;
8583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8584                         if (r->driver_path) {
8585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8587                         }
8588                         ndr->flags = _flags_save_string;
8589                 }
8590                 {
8591                         uint32_t _flags_save_string = ndr->flags;
8592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8593                         if (r->data_file) {
8594                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8596                         }
8597                         ndr->flags = _flags_save_string;
8598                 }
8599                 {
8600                         uint32_t _flags_save_string = ndr->flags;
8601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8602                         if (r->config_file) {
8603                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8605                         }
8606                         ndr->flags = _flags_save_string;
8607                 }
8608         }
8609         return NDR_ERR_SUCCESS;
8610 }
8611
8612 static enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
8613 {
8614         uint32_t _ptr_driver_name;
8615         TALLOC_CTX *_mem_save_driver_name_0;
8616         uint32_t _ptr_architecture;
8617         TALLOC_CTX *_mem_save_architecture_0;
8618         uint32_t _ptr_driver_path;
8619         TALLOC_CTX *_mem_save_driver_path_0;
8620         uint32_t _ptr_data_file;
8621         TALLOC_CTX *_mem_save_data_file_0;
8622         uint32_t _ptr_config_file;
8623         TALLOC_CTX *_mem_save_config_file_0;
8624         if (ndr_flags & NDR_SCALARS) {
8625                 NDR_CHECK(ndr_pull_align(ndr, 4));
8626                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8627                 {
8628                         uint32_t _flags_save_string = ndr->flags;
8629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8630                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8631                         if (_ptr_driver_name) {
8632                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8633                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8634                         } else {
8635                                 r->driver_name = NULL;
8636                         }
8637                         ndr->flags = _flags_save_string;
8638                 }
8639                 {
8640                         uint32_t _flags_save_string = ndr->flags;
8641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8642                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8643                         if (_ptr_architecture) {
8644                                 NDR_PULL_ALLOC(ndr, r->architecture);
8645                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8646                         } else {
8647                                 r->architecture = NULL;
8648                         }
8649                         ndr->flags = _flags_save_string;
8650                 }
8651                 {
8652                         uint32_t _flags_save_string = ndr->flags;
8653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8654                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8655                         if (_ptr_driver_path) {
8656                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8657                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8658                         } else {
8659                                 r->driver_path = NULL;
8660                         }
8661                         ndr->flags = _flags_save_string;
8662                 }
8663                 {
8664                         uint32_t _flags_save_string = ndr->flags;
8665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8666                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8667                         if (_ptr_data_file) {
8668                                 NDR_PULL_ALLOC(ndr, r->data_file);
8669                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8670                         } else {
8671                                 r->data_file = NULL;
8672                         }
8673                         ndr->flags = _flags_save_string;
8674                 }
8675                 {
8676                         uint32_t _flags_save_string = ndr->flags;
8677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8678                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8679                         if (_ptr_config_file) {
8680                                 NDR_PULL_ALLOC(ndr, r->config_file);
8681                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8682                         } else {
8683                                 r->config_file = NULL;
8684                         }
8685                         ndr->flags = _flags_save_string;
8686                 }
8687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
8688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
8689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
8690         }
8691         if (ndr_flags & NDR_BUFFERS) {
8692                 {
8693                         uint32_t _flags_save_string = ndr->flags;
8694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8695                         if (r->driver_name) {
8696                                 uint32_t _relative_save_offset;
8697                                 _relative_save_offset = ndr->offset;
8698                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8699                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8700                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8701                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8702                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8703                                 ndr->offset = _relative_save_offset;
8704                         }
8705                         ndr->flags = _flags_save_string;
8706                 }
8707                 {
8708                         uint32_t _flags_save_string = ndr->flags;
8709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8710                         if (r->architecture) {
8711                                 uint32_t _relative_save_offset;
8712                                 _relative_save_offset = ndr->offset;
8713                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8714                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8716                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8717                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_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->driver_path) {
8726                                 uint32_t _relative_save_offset;
8727                                 _relative_save_offset = ndr->offset;
8728                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8729                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8730                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8731                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8732                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_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->data_file) {
8741                                 uint32_t _relative_save_offset;
8742                                 _relative_save_offset = ndr->offset;
8743                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8744                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8745                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8746                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8747                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_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->config_file) {
8756                                 uint32_t _relative_save_offset;
8757                                 _relative_save_offset = ndr->offset;
8758                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8759                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8760                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8761                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8762                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8763                                 ndr->offset = _relative_save_offset;
8764                         }
8765                         ndr->flags = _flags_save_string;
8766                 }
8767         }
8768         return NDR_ERR_SUCCESS;
8769 }
8770
8771 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
8772 {
8773         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
8774         ndr->depth++;
8775         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8776         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8777         ndr->depth++;
8778         if (r->driver_name) {
8779                 ndr_print_string(ndr, "driver_name", r->driver_name);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "architecture", r->architecture);
8783         ndr->depth++;
8784         if (r->architecture) {
8785                 ndr_print_string(ndr, "architecture", r->architecture);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8789         ndr->depth++;
8790         if (r->driver_path) {
8791                 ndr_print_string(ndr, "driver_path", r->driver_path);
8792         }
8793         ndr->depth--;
8794         ndr_print_ptr(ndr, "data_file", r->data_file);
8795         ndr->depth++;
8796         if (r->data_file) {
8797                 ndr_print_string(ndr, "data_file", r->data_file);
8798         }
8799         ndr->depth--;
8800         ndr_print_ptr(ndr, "config_file", r->config_file);
8801         ndr->depth++;
8802         if (r->config_file) {
8803                 ndr_print_string(ndr, "config_file", r->config_file);
8804         }
8805         ndr->depth--;
8806         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
8807         ndr_print_uint32(ndr, "config_version", r->config_version);
8808         ndr_print_uint32(ndr, "driver_version", r->driver_version);
8809         ndr->depth--;
8810 }
8811
8812 static enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
8813 {
8814         if (ndr_flags & NDR_SCALARS) {
8815                 NDR_CHECK(ndr_push_align(ndr, 8));
8816                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8817                 {
8818                         uint32_t _flags_save_string = ndr->flags;
8819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8820                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8821                         ndr->flags = _flags_save_string;
8822                 }
8823                 {
8824                         uint32_t _flags_save_string = ndr->flags;
8825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8826                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8827                         ndr->flags = _flags_save_string;
8828                 }
8829                 {
8830                         uint32_t _flags_save_string = ndr->flags;
8831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8832                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8833                         ndr->flags = _flags_save_string;
8834                 }
8835                 {
8836                         uint32_t _flags_save_string = ndr->flags;
8837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8838                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8839                         ndr->flags = _flags_save_string;
8840                 }
8841                 {
8842                         uint32_t _flags_save_string = ndr->flags;
8843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8844                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8845                         ndr->flags = _flags_save_string;
8846                 }
8847                 {
8848                         uint32_t _flags_save_string = ndr->flags;
8849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8850                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8851                         ndr->flags = _flags_save_string;
8852                 }
8853                 {
8854                         uint32_t _flags_save_string_array = ndr->flags;
8855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8856                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8857                         ndr->flags = _flags_save_string_array;
8858                 }
8859                 {
8860                         uint32_t _flags_save_string = ndr->flags;
8861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8862                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8863                         ndr->flags = _flags_save_string;
8864                 }
8865                 {
8866                         uint32_t _flags_save_string = ndr->flags;
8867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8868                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8869                         ndr->flags = _flags_save_string;
8870                 }
8871                 {
8872                         uint32_t _flags_save_string_array = ndr->flags;
8873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8875                         ndr->flags = _flags_save_string_array;
8876                 }
8877                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
8878                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
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->manufacturer_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->manufacturer_url));
8889                         ndr->flags = _flags_save_string;
8890                 }
8891                 {
8892                         uint32_t _flags_save_string = ndr->flags;
8893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
8895                         ndr->flags = _flags_save_string;
8896                 }
8897                 {
8898                         uint32_t _flags_save_string = ndr->flags;
8899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8900                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
8901                         ndr->flags = _flags_save_string;
8902                 }
8903         }
8904         if (ndr_flags & NDR_BUFFERS) {
8905                 {
8906                         uint32_t _flags_save_string = ndr->flags;
8907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8908                         if (r->driver_name) {
8909                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8910                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8911                         }
8912                         ndr->flags = _flags_save_string;
8913                 }
8914                 {
8915                         uint32_t _flags_save_string = ndr->flags;
8916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8917                         if (r->architecture) {
8918                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8919                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8920                         }
8921                         ndr->flags = _flags_save_string;
8922                 }
8923                 {
8924                         uint32_t _flags_save_string = ndr->flags;
8925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8926                         if (r->driver_path) {
8927                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8928                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8929                         }
8930                         ndr->flags = _flags_save_string;
8931                 }
8932                 {
8933                         uint32_t _flags_save_string = ndr->flags;
8934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8935                         if (r->data_file) {
8936                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8937                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8938                         }
8939                         ndr->flags = _flags_save_string;
8940                 }
8941                 {
8942                         uint32_t _flags_save_string = ndr->flags;
8943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8944                         if (r->config_file) {
8945                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8946                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8947                         }
8948                         ndr->flags = _flags_save_string;
8949                 }
8950                 {
8951                         uint32_t _flags_save_string = ndr->flags;
8952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8953                         if (r->help_file) {
8954                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8955                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8956                         }
8957                         ndr->flags = _flags_save_string;
8958                 }
8959                 {
8960                         uint32_t _flags_save_string_array = ndr->flags;
8961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8962                         if (r->dependent_files) {
8963                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8964                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8965                         }
8966                         ndr->flags = _flags_save_string_array;
8967                 }
8968                 {
8969                         uint32_t _flags_save_string = ndr->flags;
8970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8971                         if (r->monitor_name) {
8972                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8973                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8974                         }
8975                         ndr->flags = _flags_save_string;
8976                 }
8977                 {
8978                         uint32_t _flags_save_string = ndr->flags;
8979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8980                         if (r->default_datatype) {
8981                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8982                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8983                         }
8984                         ndr->flags = _flags_save_string;
8985                 }
8986                 {
8987                         uint32_t _flags_save_string_array = ndr->flags;
8988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8989                         if (r->previous_names) {
8990                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8991                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8992                         }
8993                         ndr->flags = _flags_save_string_array;
8994                 }
8995                 {
8996                         uint32_t _flags_save_string = ndr->flags;
8997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8998                         if (r->manufacturer_name) {
8999                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9001                         }
9002                         ndr->flags = _flags_save_string;
9003                 }
9004                 {
9005                         uint32_t _flags_save_string = ndr->flags;
9006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9007                         if (r->manufacturer_url) {
9008                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9009                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9010                         }
9011                         ndr->flags = _flags_save_string;
9012                 }
9013                 {
9014                         uint32_t _flags_save_string = ndr->flags;
9015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9016                         if (r->hardware_id) {
9017                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9019                         }
9020                         ndr->flags = _flags_save_string;
9021                 }
9022                 {
9023                         uint32_t _flags_save_string = ndr->flags;
9024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9025                         if (r->provider) {
9026                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9027                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9028                         }
9029                         ndr->flags = _flags_save_string;
9030                 }
9031         }
9032         return NDR_ERR_SUCCESS;
9033 }
9034
9035 static enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
9036 {
9037         uint32_t _ptr_driver_name;
9038         TALLOC_CTX *_mem_save_driver_name_0;
9039         uint32_t _ptr_architecture;
9040         TALLOC_CTX *_mem_save_architecture_0;
9041         uint32_t _ptr_driver_path;
9042         TALLOC_CTX *_mem_save_driver_path_0;
9043         uint32_t _ptr_data_file;
9044         TALLOC_CTX *_mem_save_data_file_0;
9045         uint32_t _ptr_config_file;
9046         TALLOC_CTX *_mem_save_config_file_0;
9047         uint32_t _ptr_help_file;
9048         TALLOC_CTX *_mem_save_help_file_0;
9049         uint32_t _ptr_dependent_files;
9050         TALLOC_CTX *_mem_save_dependent_files_0;
9051         uint32_t _ptr_monitor_name;
9052         TALLOC_CTX *_mem_save_monitor_name_0;
9053         uint32_t _ptr_default_datatype;
9054         TALLOC_CTX *_mem_save_default_datatype_0;
9055         uint32_t _ptr_previous_names;
9056         TALLOC_CTX *_mem_save_previous_names_0;
9057         uint32_t _ptr_manufacturer_name;
9058         TALLOC_CTX *_mem_save_manufacturer_name_0;
9059         uint32_t _ptr_manufacturer_url;
9060         TALLOC_CTX *_mem_save_manufacturer_url_0;
9061         uint32_t _ptr_hardware_id;
9062         TALLOC_CTX *_mem_save_hardware_id_0;
9063         uint32_t _ptr_provider;
9064         TALLOC_CTX *_mem_save_provider_0;
9065         if (ndr_flags & NDR_SCALARS) {
9066                 NDR_CHECK(ndr_pull_align(ndr, 8));
9067                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9068                 {
9069                         uint32_t _flags_save_string = ndr->flags;
9070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9071                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9072                         if (_ptr_driver_name) {
9073                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9074                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9075                         } else {
9076                                 r->driver_name = NULL;
9077                         }
9078                         ndr->flags = _flags_save_string;
9079                 }
9080                 {
9081                         uint32_t _flags_save_string = ndr->flags;
9082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9083                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9084                         if (_ptr_architecture) {
9085                                 NDR_PULL_ALLOC(ndr, r->architecture);
9086                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9087                         } else {
9088                                 r->architecture = NULL;
9089                         }
9090                         ndr->flags = _flags_save_string;
9091                 }
9092                 {
9093                         uint32_t _flags_save_string = ndr->flags;
9094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9095                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9096                         if (_ptr_driver_path) {
9097                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9098                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9099                         } else {
9100                                 r->driver_path = NULL;
9101                         }
9102                         ndr->flags = _flags_save_string;
9103                 }
9104                 {
9105                         uint32_t _flags_save_string = ndr->flags;
9106                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9107                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9108                         if (_ptr_data_file) {
9109                                 NDR_PULL_ALLOC(ndr, r->data_file);
9110                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9111                         } else {
9112                                 r->data_file = NULL;
9113                         }
9114                         ndr->flags = _flags_save_string;
9115                 }
9116                 {
9117                         uint32_t _flags_save_string = ndr->flags;
9118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9119                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9120                         if (_ptr_config_file) {
9121                                 NDR_PULL_ALLOC(ndr, r->config_file);
9122                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9123                         } else {
9124                                 r->config_file = NULL;
9125                         }
9126                         ndr->flags = _flags_save_string;
9127                 }
9128                 {
9129                         uint32_t _flags_save_string = ndr->flags;
9130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9131                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9132                         if (_ptr_help_file) {
9133                                 NDR_PULL_ALLOC(ndr, r->help_file);
9134                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9135                         } else {
9136                                 r->help_file = NULL;
9137                         }
9138                         ndr->flags = _flags_save_string;
9139                 }
9140                 {
9141                         uint32_t _flags_save_string_array = ndr->flags;
9142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9143                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9144                         if (_ptr_dependent_files) {
9145                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9146                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9147                         } else {
9148                                 r->dependent_files = NULL;
9149                         }
9150                         ndr->flags = _flags_save_string_array;
9151                 }
9152                 {
9153                         uint32_t _flags_save_string = ndr->flags;
9154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9155                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9156                         if (_ptr_monitor_name) {
9157                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9158                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9159                         } else {
9160                                 r->monitor_name = NULL;
9161                         }
9162                         ndr->flags = _flags_save_string;
9163                 }
9164                 {
9165                         uint32_t _flags_save_string = ndr->flags;
9166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9167                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9168                         if (_ptr_default_datatype) {
9169                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9170                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9171                         } else {
9172                                 r->default_datatype = NULL;
9173                         }
9174                         ndr->flags = _flags_save_string;
9175                 }
9176                 {
9177                         uint32_t _flags_save_string_array = ndr->flags;
9178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9179                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9180                         if (_ptr_previous_names) {
9181                                 NDR_PULL_ALLOC(ndr, r->previous_names);
9182                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
9183                         } else {
9184                                 r->previous_names = NULL;
9185                         }
9186                         ndr->flags = _flags_save_string_array;
9187                 }
9188                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
9189                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9190                 {
9191                         uint32_t _flags_save_string = ndr->flags;
9192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9193                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9194                         if (_ptr_manufacturer_name) {
9195                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9196                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
9197                         } else {
9198                                 r->manufacturer_name = NULL;
9199                         }
9200                         ndr->flags = _flags_save_string;
9201                 }
9202                 {
9203                         uint32_t _flags_save_string = ndr->flags;
9204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9205                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9206                         if (_ptr_manufacturer_url) {
9207                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9208                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
9209                         } else {
9210                                 r->manufacturer_url = NULL;
9211                         }
9212                         ndr->flags = _flags_save_string;
9213                 }
9214                 {
9215                         uint32_t _flags_save_string = ndr->flags;
9216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9217                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9218                         if (_ptr_hardware_id) {
9219                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
9220                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
9221                         } else {
9222                                 r->hardware_id = NULL;
9223                         }
9224                         ndr->flags = _flags_save_string;
9225                 }
9226                 {
9227                         uint32_t _flags_save_string = ndr->flags;
9228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9229                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9230                         if (_ptr_provider) {
9231                                 NDR_PULL_ALLOC(ndr, r->provider);
9232                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
9233                         } else {
9234                                 r->provider = NULL;
9235                         }
9236                         ndr->flags = _flags_save_string;
9237                 }
9238         }
9239         if (ndr_flags & NDR_BUFFERS) {
9240                 {
9241                         uint32_t _flags_save_string = ndr->flags;
9242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9243                         if (r->driver_name) {
9244                                 uint32_t _relative_save_offset;
9245                                 _relative_save_offset = ndr->offset;
9246                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9247                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9248                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9249                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9250                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9251                                 ndr->offset = _relative_save_offset;
9252                         }
9253                         ndr->flags = _flags_save_string;
9254                 }
9255                 {
9256                         uint32_t _flags_save_string = ndr->flags;
9257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9258                         if (r->architecture) {
9259                                 uint32_t _relative_save_offset;
9260                                 _relative_save_offset = ndr->offset;
9261                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9262                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9263                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9264                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9265                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9266                                 ndr->offset = _relative_save_offset;
9267                         }
9268                         ndr->flags = _flags_save_string;
9269                 }
9270                 {
9271                         uint32_t _flags_save_string = ndr->flags;
9272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9273                         if (r->driver_path) {
9274                                 uint32_t _relative_save_offset;
9275                                 _relative_save_offset = ndr->offset;
9276                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9277                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9278                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9279                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9280                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9281                                 ndr->offset = _relative_save_offset;
9282                         }
9283                         ndr->flags = _flags_save_string;
9284                 }
9285                 {
9286                         uint32_t _flags_save_string = ndr->flags;
9287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9288                         if (r->data_file) {
9289                                 uint32_t _relative_save_offset;
9290                                 _relative_save_offset = ndr->offset;
9291                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9292                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9293                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9294                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9295                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9296                                 ndr->offset = _relative_save_offset;
9297                         }
9298                         ndr->flags = _flags_save_string;
9299                 }
9300                 {
9301                         uint32_t _flags_save_string = ndr->flags;
9302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9303                         if (r->config_file) {
9304                                 uint32_t _relative_save_offset;
9305                                 _relative_save_offset = ndr->offset;
9306                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9307                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9308                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9309                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9310                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9311                                 ndr->offset = _relative_save_offset;
9312                         }
9313                         ndr->flags = _flags_save_string;
9314                 }
9315                 {
9316                         uint32_t _flags_save_string = ndr->flags;
9317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9318                         if (r->help_file) {
9319                                 uint32_t _relative_save_offset;
9320                                 _relative_save_offset = ndr->offset;
9321                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9322                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9323                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9324                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9325                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9326                                 ndr->offset = _relative_save_offset;
9327                         }
9328                         ndr->flags = _flags_save_string;
9329                 }
9330                 {
9331                         uint32_t _flags_save_string_array = ndr->flags;
9332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9333                         if (r->dependent_files) {
9334                                 uint32_t _relative_save_offset;
9335                                 _relative_save_offset = ndr->offset;
9336                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9337                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9338                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9339                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9340                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9341                                 ndr->offset = _relative_save_offset;
9342                         }
9343                         ndr->flags = _flags_save_string_array;
9344                 }
9345                 {
9346                         uint32_t _flags_save_string = ndr->flags;
9347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9348                         if (r->monitor_name) {
9349                                 uint32_t _relative_save_offset;
9350                                 _relative_save_offset = ndr->offset;
9351                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9352                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9353                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9354                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9355                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9356                                 ndr->offset = _relative_save_offset;
9357                         }
9358                         ndr->flags = _flags_save_string;
9359                 }
9360                 {
9361                         uint32_t _flags_save_string = ndr->flags;
9362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9363                         if (r->default_datatype) {
9364                                 uint32_t _relative_save_offset;
9365                                 _relative_save_offset = ndr->offset;
9366                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9367                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9368                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9369                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9370                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9371                                 ndr->offset = _relative_save_offset;
9372                         }
9373                         ndr->flags = _flags_save_string;
9374                 }
9375                 {
9376                         uint32_t _flags_save_string_array = ndr->flags;
9377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9378                         if (r->previous_names) {
9379                                 uint32_t _relative_save_offset;
9380                                 _relative_save_offset = ndr->offset;
9381                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
9382                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9383                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9384                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
9385                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9386                                 ndr->offset = _relative_save_offset;
9387                         }
9388                         ndr->flags = _flags_save_string_array;
9389                 }
9390                 {
9391                         uint32_t _flags_save_string = ndr->flags;
9392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9393                         if (r->manufacturer_name) {
9394                                 uint32_t _relative_save_offset;
9395                                 _relative_save_offset = ndr->offset;
9396                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
9397                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9398                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9399                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
9400                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9401                                 ndr->offset = _relative_save_offset;
9402                         }
9403                         ndr->flags = _flags_save_string;
9404                 }
9405                 {
9406                         uint32_t _flags_save_string = ndr->flags;
9407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9408                         if (r->manufacturer_url) {
9409                                 uint32_t _relative_save_offset;
9410                                 _relative_save_offset = ndr->offset;
9411                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
9412                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9413                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9414                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
9415                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9416                                 ndr->offset = _relative_save_offset;
9417                         }
9418                         ndr->flags = _flags_save_string;
9419                 }
9420                 {
9421                         uint32_t _flags_save_string = ndr->flags;
9422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9423                         if (r->hardware_id) {
9424                                 uint32_t _relative_save_offset;
9425                                 _relative_save_offset = ndr->offset;
9426                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
9427                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9428                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9429                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
9430                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9431                                 ndr->offset = _relative_save_offset;
9432                         }
9433                         ndr->flags = _flags_save_string;
9434                 }
9435                 {
9436                         uint32_t _flags_save_string = ndr->flags;
9437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9438                         if (r->provider) {
9439                                 uint32_t _relative_save_offset;
9440                                 _relative_save_offset = ndr->offset;
9441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
9442                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9443                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
9445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9446                                 ndr->offset = _relative_save_offset;
9447                         }
9448                         ndr->flags = _flags_save_string;
9449                 }
9450         }
9451         return NDR_ERR_SUCCESS;
9452 }
9453
9454 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
9455 {
9456         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
9457         ndr->depth++;
9458         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9459         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9460         ndr->depth++;
9461         if (r->driver_name) {
9462                 ndr_print_string(ndr, "driver_name", r->driver_name);
9463         }
9464         ndr->depth--;
9465         ndr_print_ptr(ndr, "architecture", r->architecture);
9466         ndr->depth++;
9467         if (r->architecture) {
9468                 ndr_print_string(ndr, "architecture", r->architecture);
9469         }
9470         ndr->depth--;
9471         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9472         ndr->depth++;
9473         if (r->driver_path) {
9474                 ndr_print_string(ndr, "driver_path", r->driver_path);
9475         }
9476         ndr->depth--;
9477         ndr_print_ptr(ndr, "data_file", r->data_file);
9478         ndr->depth++;
9479         if (r->data_file) {
9480                 ndr_print_string(ndr, "data_file", r->data_file);
9481         }
9482         ndr->depth--;
9483         ndr_print_ptr(ndr, "config_file", r->config_file);
9484         ndr->depth++;
9485         if (r->config_file) {
9486                 ndr_print_string(ndr, "config_file", r->config_file);
9487         }
9488         ndr->depth--;
9489         ndr_print_ptr(ndr, "help_file", r->help_file);
9490         ndr->depth++;
9491         if (r->help_file) {
9492                 ndr_print_string(ndr, "help_file", r->help_file);
9493         }
9494         ndr->depth--;
9495         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9496         ndr->depth++;
9497         if (r->dependent_files) {
9498                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9499         }
9500         ndr->depth--;
9501         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9502         ndr->depth++;
9503         if (r->monitor_name) {
9504                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9505         }
9506         ndr->depth--;
9507         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9508         ndr->depth++;
9509         if (r->default_datatype) {
9510                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9511         }
9512         ndr->depth--;
9513         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9514         ndr->depth++;
9515         if (r->previous_names) {
9516                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
9517         }
9518         ndr->depth--;
9519         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
9520         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9521         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9522         ndr->depth++;
9523         if (r->manufacturer_name) {
9524                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9525         }
9526         ndr->depth--;
9527         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9528         ndr->depth++;
9529         if (r->manufacturer_url) {
9530                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9531         }
9532         ndr->depth--;
9533         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9534         ndr->depth++;
9535         if (r->hardware_id) {
9536                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9537         }
9538         ndr->depth--;
9539         ndr_print_ptr(ndr, "provider", r->provider);
9540         ndr->depth++;
9541         if (r->provider) {
9542                 ndr_print_string(ndr, "provider", r->provider);
9543         }
9544         ndr->depth--;
9545         ndr->depth--;
9546 }
9547
9548 static enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
9549 {
9550         if (ndr_flags & NDR_SCALARS) {
9551                 NDR_CHECK(ndr_push_align(ndr, 8));
9552                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9553                 {
9554                         uint32_t _flags_save_string = ndr->flags;
9555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9556                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9557                         ndr->flags = _flags_save_string;
9558                 }
9559                 {
9560                         uint32_t _flags_save_string = ndr->flags;
9561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9563                         ndr->flags = _flags_save_string;
9564                 }
9565                 {
9566                         uint32_t _flags_save_string = ndr->flags;
9567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9568                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9569                         ndr->flags = _flags_save_string;
9570                 }
9571                 {
9572                         uint32_t _flags_save_string = ndr->flags;
9573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9574                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9575                         ndr->flags = _flags_save_string;
9576                 }
9577                 {
9578                         uint32_t _flags_save_string = ndr->flags;
9579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9580                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9581                         ndr->flags = _flags_save_string;
9582                 }
9583                 {
9584                         uint32_t _flags_save_string = ndr->flags;
9585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9586                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
9587                         ndr->flags = _flags_save_string;
9588                 }
9589                 {
9590                         uint32_t _flags_save_string = ndr->flags;
9591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9592                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
9593                         ndr->flags = _flags_save_string;
9594                 }
9595                 {
9596                         uint32_t _flags_save_string = ndr->flags;
9597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9598                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
9599                         ndr->flags = _flags_save_string;
9600                 }
9601                 {
9602                         uint32_t _flags_save_string_array = ndr->flags;
9603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9604                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
9605                         ndr->flags = _flags_save_string_array;
9606                 }
9607                 {
9608                         uint32_t _flags_save_string_array = ndr->flags;
9609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9610                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
9611                         ndr->flags = _flags_save_string_array;
9612                 }
9613                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
9614                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9615                 {
9616                         uint32_t _flags_save_string = ndr->flags;
9617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9618                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
9619                         ndr->flags = _flags_save_string;
9620                 }
9621                 {
9622                         uint32_t _flags_save_string = ndr->flags;
9623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9624                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
9625                         ndr->flags = _flags_save_string;
9626                 }
9627                 {
9628                         uint32_t _flags_save_string = ndr->flags;
9629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9630                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
9631                         ndr->flags = _flags_save_string;
9632                 }
9633                 {
9634                         uint32_t _flags_save_string = ndr->flags;
9635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9636                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
9637                         ndr->flags = _flags_save_string;
9638                 }
9639                 {
9640                         uint32_t _flags_save_string = ndr->flags;
9641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9642                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
9643                         ndr->flags = _flags_save_string;
9644                 }
9645                 {
9646                         uint32_t _flags_save_string = ndr->flags;
9647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9648                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
9649                         ndr->flags = _flags_save_string;
9650                 }
9651                 {
9652                         uint32_t _flags_save_string_array = ndr->flags;
9653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9654                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
9655                         ndr->flags = _flags_save_string_array;
9656                 }
9657                 {
9658                         uint32_t _flags_save_string = ndr->flags;
9659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9660                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
9661                         ndr->flags = _flags_save_string;
9662                 }
9663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9664                 {
9665                         uint32_t _flags_save_string_array = ndr->flags;
9666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9667                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
9668                         ndr->flags = _flags_save_string_array;
9669                 }
9670                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9671                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9672         }
9673         if (ndr_flags & NDR_BUFFERS) {
9674                 {
9675                         uint32_t _flags_save_string = ndr->flags;
9676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9677                         if (r->driver_name) {
9678                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9679                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9680                         }
9681                         ndr->flags = _flags_save_string;
9682                 }
9683                 {
9684                         uint32_t _flags_save_string = ndr->flags;
9685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9686                         if (r->architecture) {
9687                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9688                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9689                         }
9690                         ndr->flags = _flags_save_string;
9691                 }
9692                 {
9693                         uint32_t _flags_save_string = ndr->flags;
9694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9695                         if (r->driver_path) {
9696                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9697                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9698                         }
9699                         ndr->flags = _flags_save_string;
9700                 }
9701                 {
9702                         uint32_t _flags_save_string = ndr->flags;
9703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9704                         if (r->data_file) {
9705                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9706                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9707                         }
9708                         ndr->flags = _flags_save_string;
9709                 }
9710                 {
9711                         uint32_t _flags_save_string = ndr->flags;
9712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9713                         if (r->config_file) {
9714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9716                         }
9717                         ndr->flags = _flags_save_string;
9718                 }
9719                 {
9720                         uint32_t _flags_save_string = ndr->flags;
9721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9722                         if (r->help_file) {
9723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
9724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
9725                         }
9726                         ndr->flags = _flags_save_string;
9727                 }
9728                 {
9729                         uint32_t _flags_save_string = ndr->flags;
9730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9731                         if (r->monitor_name) {
9732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
9733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
9734                         }
9735                         ndr->flags = _flags_save_string;
9736                 }
9737                 {
9738                         uint32_t _flags_save_string = ndr->flags;
9739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9740                         if (r->default_datatype) {
9741                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9743                         }
9744                         ndr->flags = _flags_save_string;
9745                 }
9746                 {
9747                         uint32_t _flags_save_string_array = ndr->flags;
9748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9749                         if (r->dependent_files) {
9750                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
9751                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
9752                         }
9753                         ndr->flags = _flags_save_string_array;
9754                 }
9755                 {
9756                         uint32_t _flags_save_string_array = ndr->flags;
9757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9758                         if (r->previous_names) {
9759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9760                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9761                         }
9762                         ndr->flags = _flags_save_string_array;
9763                 }
9764                 {
9765                         uint32_t _flags_save_string = ndr->flags;
9766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9767                         if (r->manufacturer_name) {
9768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9770                         }
9771                         ndr->flags = _flags_save_string;
9772                 }
9773                 {
9774                         uint32_t _flags_save_string = ndr->flags;
9775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9776                         if (r->manufacturer_url) {
9777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9779                         }
9780                         ndr->flags = _flags_save_string;
9781                 }
9782                 {
9783                         uint32_t _flags_save_string = ndr->flags;
9784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9785                         if (r->hardware_id) {
9786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9788                         }
9789                         ndr->flags = _flags_save_string;
9790                 }
9791                 {
9792                         uint32_t _flags_save_string = ndr->flags;
9793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9794                         if (r->provider) {
9795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9797                         }
9798                         ndr->flags = _flags_save_string;
9799                 }
9800                 {
9801                         uint32_t _flags_save_string = ndr->flags;
9802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9803                         if (r->print_processor) {
9804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
9805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
9806                         }
9807                         ndr->flags = _flags_save_string;
9808                 }
9809                 {
9810                         uint32_t _flags_save_string = ndr->flags;
9811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9812                         if (r->vendor_setup) {
9813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
9814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
9815                         }
9816                         ndr->flags = _flags_save_string;
9817                 }
9818                 {
9819                         uint32_t _flags_save_string_array = ndr->flags;
9820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9821                         if (r->color_profiles) {
9822                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
9823                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
9824                         }
9825                         ndr->flags = _flags_save_string_array;
9826                 }
9827                 {
9828                         uint32_t _flags_save_string = ndr->flags;
9829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9830                         if (r->inf_path) {
9831                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
9832                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
9833                         }
9834                         ndr->flags = _flags_save_string;
9835                 }
9836                 {
9837                         uint32_t _flags_save_string_array = ndr->flags;
9838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9839                         if (r->core_driver_dependencies) {
9840                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
9841                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
9842                         }
9843                         ndr->flags = _flags_save_string_array;
9844                 }
9845         }
9846         return NDR_ERR_SUCCESS;
9847 }
9848
9849 static enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
9850 {
9851         uint32_t _ptr_driver_name;
9852         TALLOC_CTX *_mem_save_driver_name_0;
9853         uint32_t _ptr_architecture;
9854         TALLOC_CTX *_mem_save_architecture_0;
9855         uint32_t _ptr_driver_path;
9856         TALLOC_CTX *_mem_save_driver_path_0;
9857         uint32_t _ptr_data_file;
9858         TALLOC_CTX *_mem_save_data_file_0;
9859         uint32_t _ptr_config_file;
9860         TALLOC_CTX *_mem_save_config_file_0;
9861         uint32_t _ptr_help_file;
9862         TALLOC_CTX *_mem_save_help_file_0;
9863         uint32_t _ptr_monitor_name;
9864         TALLOC_CTX *_mem_save_monitor_name_0;
9865         uint32_t _ptr_default_datatype;
9866         TALLOC_CTX *_mem_save_default_datatype_0;
9867         uint32_t _ptr_dependent_files;
9868         TALLOC_CTX *_mem_save_dependent_files_0;
9869         uint32_t _ptr_previous_names;
9870         TALLOC_CTX *_mem_save_previous_names_0;
9871         uint32_t _ptr_manufacturer_name;
9872         TALLOC_CTX *_mem_save_manufacturer_name_0;
9873         uint32_t _ptr_manufacturer_url;
9874         TALLOC_CTX *_mem_save_manufacturer_url_0;
9875         uint32_t _ptr_hardware_id;
9876         TALLOC_CTX *_mem_save_hardware_id_0;
9877         uint32_t _ptr_provider;
9878         TALLOC_CTX *_mem_save_provider_0;
9879         uint32_t _ptr_print_processor;
9880         TALLOC_CTX *_mem_save_print_processor_0;
9881         uint32_t _ptr_vendor_setup;
9882         TALLOC_CTX *_mem_save_vendor_setup_0;
9883         uint32_t _ptr_color_profiles;
9884         TALLOC_CTX *_mem_save_color_profiles_0;
9885         uint32_t _ptr_inf_path;
9886         TALLOC_CTX *_mem_save_inf_path_0;
9887         uint32_t _ptr_core_driver_dependencies;
9888         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9889         if (ndr_flags & NDR_SCALARS) {
9890                 NDR_CHECK(ndr_pull_align(ndr, 8));
9891                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9892                 {
9893                         uint32_t _flags_save_string = ndr->flags;
9894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9895                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9896                         if (_ptr_driver_name) {
9897                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9898                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9899                         } else {
9900                                 r->driver_name = NULL;
9901                         }
9902                         ndr->flags = _flags_save_string;
9903                 }
9904                 {
9905                         uint32_t _flags_save_string = ndr->flags;
9906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9908                         if (_ptr_architecture) {
9909                                 NDR_PULL_ALLOC(ndr, r->architecture);
9910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9911                         } else {
9912                                 r->architecture = NULL;
9913                         }
9914                         ndr->flags = _flags_save_string;
9915                 }
9916                 {
9917                         uint32_t _flags_save_string = ndr->flags;
9918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9920                         if (_ptr_driver_path) {
9921                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9923                         } else {
9924                                 r->driver_path = NULL;
9925                         }
9926                         ndr->flags = _flags_save_string;
9927                 }
9928                 {
9929                         uint32_t _flags_save_string = ndr->flags;
9930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9931                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9932                         if (_ptr_data_file) {
9933                                 NDR_PULL_ALLOC(ndr, r->data_file);
9934                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9935                         } else {
9936                                 r->data_file = NULL;
9937                         }
9938                         ndr->flags = _flags_save_string;
9939                 }
9940                 {
9941                         uint32_t _flags_save_string = ndr->flags;
9942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9943                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9944                         if (_ptr_config_file) {
9945                                 NDR_PULL_ALLOC(ndr, r->config_file);
9946                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9947                         } else {
9948                                 r->config_file = NULL;
9949                         }
9950                         ndr->flags = _flags_save_string;
9951                 }
9952                 {
9953                         uint32_t _flags_save_string = ndr->flags;
9954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9955                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9956                         if (_ptr_help_file) {
9957                                 NDR_PULL_ALLOC(ndr, r->help_file);
9958                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9959                         } else {
9960                                 r->help_file = NULL;
9961                         }
9962                         ndr->flags = _flags_save_string;
9963                 }
9964                 {
9965                         uint32_t _flags_save_string = ndr->flags;
9966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9967                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9968                         if (_ptr_monitor_name) {
9969                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9970                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9971                         } else {
9972                                 r->monitor_name = NULL;
9973                         }
9974                         ndr->flags = _flags_save_string;
9975                 }
9976                 {
9977                         uint32_t _flags_save_string = ndr->flags;
9978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9979                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9980                         if (_ptr_default_datatype) {
9981                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9982                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9983                         } else {
9984                                 r->default_datatype = NULL;
9985                         }
9986                         ndr->flags = _flags_save_string;
9987                 }
9988                 {
9989                         uint32_t _flags_save_string_array = ndr->flags;
9990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9991                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9992                         if (_ptr_dependent_files) {
9993                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9994                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9995                         } else {
9996                                 r->dependent_files = NULL;
9997                         }
9998                         ndr->flags = _flags_save_string_array;
9999                 }
10000                 {
10001                         uint32_t _flags_save_string_array = ndr->flags;
10002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10003                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10004                         if (_ptr_previous_names) {
10005                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10006                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10007                         } else {
10008                                 r->previous_names = NULL;
10009                         }
10010                         ndr->flags = _flags_save_string_array;
10011                 }
10012                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
10013                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10014                 {
10015                         uint32_t _flags_save_string = ndr->flags;
10016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10017                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10018                         if (_ptr_manufacturer_name) {
10019                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10020                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
10021                         } else {
10022                                 r->manufacturer_name = NULL;
10023                         }
10024                         ndr->flags = _flags_save_string;
10025                 }
10026                 {
10027                         uint32_t _flags_save_string = ndr->flags;
10028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10029                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10030                         if (_ptr_manufacturer_url) {
10031                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10032                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
10033                         } else {
10034                                 r->manufacturer_url = NULL;
10035                         }
10036                         ndr->flags = _flags_save_string;
10037                 }
10038                 {
10039                         uint32_t _flags_save_string = ndr->flags;
10040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10041                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10042                         if (_ptr_hardware_id) {
10043                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
10044                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
10045                         } else {
10046                                 r->hardware_id = NULL;
10047                         }
10048                         ndr->flags = _flags_save_string;
10049                 }
10050                 {
10051                         uint32_t _flags_save_string = ndr->flags;
10052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10053                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10054                         if (_ptr_provider) {
10055                                 NDR_PULL_ALLOC(ndr, r->provider);
10056                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
10057                         } else {
10058                                 r->provider = NULL;
10059                         }
10060                         ndr->flags = _flags_save_string;
10061                 }
10062                 {
10063                         uint32_t _flags_save_string = ndr->flags;
10064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10066                         if (_ptr_print_processor) {
10067                                 NDR_PULL_ALLOC(ndr, r->print_processor);
10068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
10069                         } else {
10070                                 r->print_processor = NULL;
10071                         }
10072                         ndr->flags = _flags_save_string;
10073                 }
10074                 {
10075                         uint32_t _flags_save_string = ndr->flags;
10076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10077                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10078                         if (_ptr_vendor_setup) {
10079                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
10080                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
10081                         } else {
10082                                 r->vendor_setup = NULL;
10083                         }
10084                         ndr->flags = _flags_save_string;
10085                 }
10086                 {
10087                         uint32_t _flags_save_string_array = ndr->flags;
10088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10089                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10090                         if (_ptr_color_profiles) {
10091                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
10092                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
10093                         } else {
10094                                 r->color_profiles = NULL;
10095                         }
10096                         ndr->flags = _flags_save_string_array;
10097                 }
10098                 {
10099                         uint32_t _flags_save_string = ndr->flags;
10100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10101                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10102                         if (_ptr_inf_path) {
10103                                 NDR_PULL_ALLOC(ndr, r->inf_path);
10104                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
10105                         } else {
10106                                 r->inf_path = NULL;
10107                         }
10108                         ndr->flags = _flags_save_string;
10109                 }
10110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
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_core_driver_dependencies));
10115                         if (_ptr_core_driver_dependencies) {
10116                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10117                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
10118                         } else {
10119                                 r->core_driver_dependencies = NULL;
10120                         }
10121                         ndr->flags = _flags_save_string_array;
10122                 }
10123                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10124                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10125         }
10126         if (ndr_flags & NDR_BUFFERS) {
10127                 {
10128                         uint32_t _flags_save_string = ndr->flags;
10129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10130                         if (r->driver_name) {
10131                                 uint32_t _relative_save_offset;
10132                                 _relative_save_offset = ndr->offset;
10133                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10134                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10135                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10136                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10137                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10138                                 ndr->offset = _relative_save_offset;
10139                         }
10140                         ndr->flags = _flags_save_string;
10141                 }
10142                 {
10143                         uint32_t _flags_save_string = ndr->flags;
10144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10145                         if (r->architecture) {
10146                                 uint32_t _relative_save_offset;
10147                                 _relative_save_offset = ndr->offset;
10148                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10149                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10150                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10151                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10152                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10153                                 ndr->offset = _relative_save_offset;
10154                         }
10155                         ndr->flags = _flags_save_string;
10156                 }
10157                 {
10158                         uint32_t _flags_save_string = ndr->flags;
10159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10160                         if (r->driver_path) {
10161                                 uint32_t _relative_save_offset;
10162                                 _relative_save_offset = ndr->offset;
10163                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10164                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10165                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10166                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10167                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10168                                 ndr->offset = _relative_save_offset;
10169                         }
10170                         ndr->flags = _flags_save_string;
10171                 }
10172                 {
10173                         uint32_t _flags_save_string = ndr->flags;
10174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10175                         if (r->data_file) {
10176                                 uint32_t _relative_save_offset;
10177                                 _relative_save_offset = ndr->offset;
10178                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10179                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10180                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10181                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10182                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10183                                 ndr->offset = _relative_save_offset;
10184                         }
10185                         ndr->flags = _flags_save_string;
10186                 }
10187                 {
10188                         uint32_t _flags_save_string = ndr->flags;
10189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10190                         if (r->config_file) {
10191                                 uint32_t _relative_save_offset;
10192                                 _relative_save_offset = ndr->offset;
10193                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10194                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10195                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10196                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10197                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10198                                 ndr->offset = _relative_save_offset;
10199                         }
10200                         ndr->flags = _flags_save_string;
10201                 }
10202                 {
10203                         uint32_t _flags_save_string = ndr->flags;
10204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10205                         if (r->help_file) {
10206                                 uint32_t _relative_save_offset;
10207                                 _relative_save_offset = ndr->offset;
10208                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10209                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10210                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10211                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10212                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10213                                 ndr->offset = _relative_save_offset;
10214                         }
10215                         ndr->flags = _flags_save_string;
10216                 }
10217                 {
10218                         uint32_t _flags_save_string = ndr->flags;
10219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10220                         if (r->monitor_name) {
10221                                 uint32_t _relative_save_offset;
10222                                 _relative_save_offset = ndr->offset;
10223                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10224                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10225                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10226                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10227                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10228                                 ndr->offset = _relative_save_offset;
10229                         }
10230                         ndr->flags = _flags_save_string;
10231                 }
10232                 {
10233                         uint32_t _flags_save_string = ndr->flags;
10234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10235                         if (r->default_datatype) {
10236                                 uint32_t _relative_save_offset;
10237                                 _relative_save_offset = ndr->offset;
10238                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10239                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10240                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10241                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10242                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10243                                 ndr->offset = _relative_save_offset;
10244                         }
10245                         ndr->flags = _flags_save_string;
10246                 }
10247                 {
10248                         uint32_t _flags_save_string_array = ndr->flags;
10249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10250                         if (r->dependent_files) {
10251                                 uint32_t _relative_save_offset;
10252                                 _relative_save_offset = ndr->offset;
10253                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10254                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10255                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10256                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10257                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10258                                 ndr->offset = _relative_save_offset;
10259                         }
10260                         ndr->flags = _flags_save_string_array;
10261                 }
10262                 {
10263                         uint32_t _flags_save_string_array = ndr->flags;
10264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10265                         if (r->previous_names) {
10266                                 uint32_t _relative_save_offset;
10267                                 _relative_save_offset = ndr->offset;
10268                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
10269                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10270                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10271                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
10272                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10273                                 ndr->offset = _relative_save_offset;
10274                         }
10275                         ndr->flags = _flags_save_string_array;
10276                 }
10277                 {
10278                         uint32_t _flags_save_string = ndr->flags;
10279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10280                         if (r->manufacturer_name) {
10281                                 uint32_t _relative_save_offset;
10282                                 _relative_save_offset = ndr->offset;
10283                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
10284                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10285                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10286                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
10287                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10288                                 ndr->offset = _relative_save_offset;
10289                         }
10290                         ndr->flags = _flags_save_string;
10291                 }
10292                 {
10293                         uint32_t _flags_save_string = ndr->flags;
10294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10295                         if (r->manufacturer_url) {
10296                                 uint32_t _relative_save_offset;
10297                                 _relative_save_offset = ndr->offset;
10298                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
10299                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10300                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10301                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
10302                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10303                                 ndr->offset = _relative_save_offset;
10304                         }
10305                         ndr->flags = _flags_save_string;
10306                 }
10307                 {
10308                         uint32_t _flags_save_string = ndr->flags;
10309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10310                         if (r->hardware_id) {
10311                                 uint32_t _relative_save_offset;
10312                                 _relative_save_offset = ndr->offset;
10313                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
10314                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10315                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10316                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
10317                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10318                                 ndr->offset = _relative_save_offset;
10319                         }
10320                         ndr->flags = _flags_save_string;
10321                 }
10322                 {
10323                         uint32_t _flags_save_string = ndr->flags;
10324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10325                         if (r->provider) {
10326                                 uint32_t _relative_save_offset;
10327                                 _relative_save_offset = ndr->offset;
10328                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
10329                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10330                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10331                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
10332                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10333                                 ndr->offset = _relative_save_offset;
10334                         }
10335                         ndr->flags = _flags_save_string;
10336                 }
10337                 {
10338                         uint32_t _flags_save_string = ndr->flags;
10339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10340                         if (r->print_processor) {
10341                                 uint32_t _relative_save_offset;
10342                                 _relative_save_offset = ndr->offset;
10343                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
10344                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10345                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10346                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
10347                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10348                                 ndr->offset = _relative_save_offset;
10349                         }
10350                         ndr->flags = _flags_save_string;
10351                 }
10352                 {
10353                         uint32_t _flags_save_string = ndr->flags;
10354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10355                         if (r->vendor_setup) {
10356                                 uint32_t _relative_save_offset;
10357                                 _relative_save_offset = ndr->offset;
10358                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
10359                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10360                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10361                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
10362                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10363                                 ndr->offset = _relative_save_offset;
10364                         }
10365                         ndr->flags = _flags_save_string;
10366                 }
10367                 {
10368                         uint32_t _flags_save_string_array = ndr->flags;
10369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10370                         if (r->color_profiles) {
10371                                 uint32_t _relative_save_offset;
10372                                 _relative_save_offset = ndr->offset;
10373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
10374                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10375                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10376                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
10377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10378                                 ndr->offset = _relative_save_offset;
10379                         }
10380                         ndr->flags = _flags_save_string_array;
10381                 }
10382                 {
10383                         uint32_t _flags_save_string = ndr->flags;
10384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10385                         if (r->inf_path) {
10386                                 uint32_t _relative_save_offset;
10387                                 _relative_save_offset = ndr->offset;
10388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
10389                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10390                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
10392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10393                                 ndr->offset = _relative_save_offset;
10394                         }
10395                         ndr->flags = _flags_save_string;
10396                 }
10397                 {
10398                         uint32_t _flags_save_string_array = ndr->flags;
10399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10400                         if (r->core_driver_dependencies) {
10401                                 uint32_t _relative_save_offset;
10402                                 _relative_save_offset = ndr->offset;
10403                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
10404                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10405                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10406                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
10407                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10408                                 ndr->offset = _relative_save_offset;
10409                         }
10410                         ndr->flags = _flags_save_string_array;
10411                 }
10412         }
10413         return NDR_ERR_SUCCESS;
10414 }
10415
10416 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
10417 {
10418         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
10419         ndr->depth++;
10420         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10421         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10422         ndr->depth++;
10423         if (r->driver_name) {
10424                 ndr_print_string(ndr, "driver_name", r->driver_name);
10425         }
10426         ndr->depth--;
10427         ndr_print_ptr(ndr, "architecture", r->architecture);
10428         ndr->depth++;
10429         if (r->architecture) {
10430                 ndr_print_string(ndr, "architecture", r->architecture);
10431         }
10432         ndr->depth--;
10433         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10434         ndr->depth++;
10435         if (r->driver_path) {
10436                 ndr_print_string(ndr, "driver_path", r->driver_path);
10437         }
10438         ndr->depth--;
10439         ndr_print_ptr(ndr, "data_file", r->data_file);
10440         ndr->depth++;
10441         if (r->data_file) {
10442                 ndr_print_string(ndr, "data_file", r->data_file);
10443         }
10444         ndr->depth--;
10445         ndr_print_ptr(ndr, "config_file", r->config_file);
10446         ndr->depth++;
10447         if (r->config_file) {
10448                 ndr_print_string(ndr, "config_file", r->config_file);
10449         }
10450         ndr->depth--;
10451         ndr_print_ptr(ndr, "help_file", r->help_file);
10452         ndr->depth++;
10453         if (r->help_file) {
10454                 ndr_print_string(ndr, "help_file", r->help_file);
10455         }
10456         ndr->depth--;
10457         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10458         ndr->depth++;
10459         if (r->monitor_name) {
10460                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10461         }
10462         ndr->depth--;
10463         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10464         ndr->depth++;
10465         if (r->default_datatype) {
10466                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10467         }
10468         ndr->depth--;
10469         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10470         ndr->depth++;
10471         if (r->dependent_files) {
10472                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10473         }
10474         ndr->depth--;
10475         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10476         ndr->depth++;
10477         if (r->previous_names) {
10478                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10479         }
10480         ndr->depth--;
10481         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
10482         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10483         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10484         ndr->depth++;
10485         if (r->manufacturer_name) {
10486                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10487         }
10488         ndr->depth--;
10489         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10490         ndr->depth++;
10491         if (r->manufacturer_url) {
10492                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10493         }
10494         ndr->depth--;
10495         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10496         ndr->depth++;
10497         if (r->hardware_id) {
10498                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10499         }
10500         ndr->depth--;
10501         ndr_print_ptr(ndr, "provider", r->provider);
10502         ndr->depth++;
10503         if (r->provider) {
10504                 ndr_print_string(ndr, "provider", r->provider);
10505         }
10506         ndr->depth--;
10507         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10508         ndr->depth++;
10509         if (r->print_processor) {
10510                 ndr_print_string(ndr, "print_processor", r->print_processor);
10511         }
10512         ndr->depth--;
10513         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10514         ndr->depth++;
10515         if (r->vendor_setup) {
10516                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10517         }
10518         ndr->depth--;
10519         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10520         ndr->depth++;
10521         if (r->color_profiles) {
10522                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
10523         }
10524         ndr->depth--;
10525         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10526         ndr->depth++;
10527         if (r->inf_path) {
10528                 ndr_print_string(ndr, "inf_path", r->inf_path);
10529         }
10530         ndr->depth--;
10531         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10532         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10533         ndr->depth++;
10534         if (r->core_driver_dependencies) {
10535                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10536         }
10537         ndr->depth--;
10538         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10539         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10540         ndr->depth--;
10541 }
10542
10543 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
10544 {
10545         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10546         if (ndr_flags & NDR_SCALARS) {
10547                 int level = ndr_push_get_switch_value(ndr, r);
10548                 switch (level) {
10549                         case 1: {
10550                                 NDR_CHECK(ndr_push_align(ndr, 4));
10551                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10552                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10553                         break; }
10554
10555                         case 2: {
10556                                 NDR_CHECK(ndr_push_align(ndr, 4));
10557                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10558                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10559                         break; }
10560
10561                         case 3: {
10562                                 NDR_CHECK(ndr_push_align(ndr, 4));
10563                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10564                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10565                         break; }
10566
10567                         case 4: {
10568                                 NDR_CHECK(ndr_push_align(ndr, 4));
10569                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10570                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10571                         break; }
10572
10573                         case 5: {
10574                                 NDR_CHECK(ndr_push_align(ndr, 4));
10575                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10576                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10577                         break; }
10578
10579                         case 6: {
10580                                 NDR_CHECK(ndr_push_align(ndr, 8));
10581                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10582                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10583                         break; }
10584
10585                         case 8: {
10586                                 NDR_CHECK(ndr_push_align(ndr, 8));
10587                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10588                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10589                         break; }
10590
10591                         default: {
10592                         break; }
10593
10594                 }
10595         }
10596         if (ndr_flags & NDR_BUFFERS) {
10597                 int level = ndr_push_get_switch_value(ndr, r);
10598                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10599                 switch (level) {
10600                         case 1:
10601                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10602                         break;
10603
10604                         case 2:
10605                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10606                         break;
10607
10608                         case 3:
10609                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10610                         break;
10611
10612                         case 4:
10613                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10614                         break;
10615
10616                         case 5:
10617                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10618                         break;
10619
10620                         case 6:
10621                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10622                         break;
10623
10624                         case 8:
10625                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10626                         break;
10627
10628                         default:
10629                         break;
10630
10631                 }
10632         }
10633         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10634         return NDR_ERR_SUCCESS;
10635 }
10636
10637 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
10638 {
10639         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10640         int level;
10641         level = ndr_pull_get_switch_value(ndr, r);
10642         if (ndr_flags & NDR_SCALARS) {
10643                 switch (level) {
10644                         case 1: {
10645                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10646                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10647                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10648                         break; }
10649
10650                         case 2: {
10651                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10652                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10653                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10654                         break; }
10655
10656                         case 3: {
10657                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10658                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10659                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10660                         break; }
10661
10662                         case 4: {
10663                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10664                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10665                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10666                         break; }
10667
10668                         case 5: {
10669                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10670                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10671                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10672                         break; }
10673
10674                         case 6: {
10675                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10676                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10677                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10678                         break; }
10679
10680                         case 8: {
10681                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10682                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10683                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10684                         break; }
10685
10686                         default: {
10687                         break; }
10688
10689                 }
10690         }
10691         if (ndr_flags & NDR_BUFFERS) {
10692                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10693                 switch (level) {
10694                         case 1:
10695                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10696                         break;
10697
10698                         case 2:
10699                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10700                         break;
10701
10702                         case 3:
10703                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10704                         break;
10705
10706                         case 4:
10707                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10708                         break;
10709
10710                         case 5:
10711                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10712                         break;
10713
10714                         case 6:
10715                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10716                         break;
10717
10718                         case 8:
10719                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10720                         break;
10721
10722                         default:
10723                         break;
10724
10725                 }
10726         }
10727         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10728         return NDR_ERR_SUCCESS;
10729 }
10730
10731 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
10732 {
10733         int level;
10734         level = ndr_print_get_switch_value(ndr, r);
10735         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
10736         switch (level) {
10737                 case 1:
10738                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
10739                 break;
10740
10741                 case 2:
10742                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
10743                 break;
10744
10745                 case 3:
10746                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
10747                 break;
10748
10749                 case 4:
10750                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
10751                 break;
10752
10753                 case 5:
10754                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
10755                 break;
10756
10757                 case 6:
10758                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
10759                 break;
10760
10761                 case 8:
10762                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
10763                 break;
10764
10765                 default:
10766                 break;
10767
10768         }
10769 }
10770
10771 static enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
10772 {
10773         if (ndr_flags & NDR_SCALARS) {
10774                 NDR_CHECK(ndr_push_align(ndr, 4));
10775                 {
10776                         uint32_t _flags_save_string = ndr->flags;
10777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10778                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
10779                         ndr->flags = _flags_save_string;
10780                 }
10781         }
10782         if (ndr_flags & NDR_BUFFERS) {
10783         }
10784         return NDR_ERR_SUCCESS;
10785 }
10786
10787 static enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
10788 {
10789         if (ndr_flags & NDR_SCALARS) {
10790                 NDR_CHECK(ndr_pull_align(ndr, 4));
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
10795                         ndr->flags = _flags_save_string;
10796                 }
10797         }
10798         if (ndr_flags & NDR_BUFFERS) {
10799         }
10800         return NDR_ERR_SUCCESS;
10801 }
10802
10803 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
10804 {
10805         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
10806         ndr->depth++;
10807         ndr_print_string(ndr, "directory_name", r->directory_name);
10808         ndr->depth--;
10809 }
10810
10811 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
10812 {
10813         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10814         if (ndr_flags & NDR_SCALARS) {
10815                 int level = ndr_push_get_switch_value(ndr, r);
10816                 switch (level) {
10817                         case 1: {
10818                                 NDR_CHECK(ndr_push_align(ndr, 4));
10819                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10820                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10821                         break; }
10822
10823                         default: {
10824                                 NDR_CHECK(ndr_push_align(ndr, 4));
10825                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10826                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10827                         break; }
10828
10829                 }
10830         }
10831         if (ndr_flags & NDR_BUFFERS) {
10832                 int level = ndr_push_get_switch_value(ndr, r);
10833                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10834                 switch (level) {
10835                         case 1:
10836                         break;
10837
10838                         default:
10839                         break;
10840
10841                 }
10842         }
10843         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10844         return NDR_ERR_SUCCESS;
10845 }
10846
10847 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
10848 {
10849         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10850         int level;
10851         level = ndr_pull_get_switch_value(ndr, r);
10852         if (ndr_flags & NDR_SCALARS) {
10853                 switch (level) {
10854                         case 1: {
10855                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10856                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10857                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10858                         break; }
10859
10860                         default: {
10861                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10862                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10863                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10864                         break; }
10865
10866                 }
10867         }
10868         if (ndr_flags & NDR_BUFFERS) {
10869                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10870                 switch (level) {
10871                         case 1:
10872                         break;
10873
10874                         default:
10875                         break;
10876
10877                 }
10878         }
10879         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10880         return NDR_ERR_SUCCESS;
10881 }
10882
10883 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
10884 {
10885         int level;
10886         level = ndr_print_get_switch_value(ndr, r);
10887         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
10888         switch (level) {
10889                 case 1:
10890                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10891                 break;
10892
10893                 default:
10894                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10895                 break;
10896
10897         }
10898 }
10899
10900 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
10901 {
10902         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
10903 }
10904
10905 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
10906 {
10907         if (ndr_flags & NDR_SCALARS) {
10908                 NDR_CHECK(ndr_push_align(ndr, 4));
10909                 {
10910                         uint32_t _flags_save_string = ndr->flags;
10911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10912                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
10913                         ndr->flags = _flags_save_string;
10914                 }
10915         }
10916         if (ndr_flags & NDR_BUFFERS) {
10917                 {
10918                         uint32_t _flags_save_string = ndr->flags;
10919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10920                         if (r->print_processor_name) {
10921                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
10922                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
10923                         }
10924                         ndr->flags = _flags_save_string;
10925                 }
10926         }
10927         return NDR_ERR_SUCCESS;
10928 }
10929
10930 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
10931 {
10932         uint32_t _ptr_print_processor_name;
10933         TALLOC_CTX *_mem_save_print_processor_name_0;
10934         if (ndr_flags & NDR_SCALARS) {
10935                 NDR_CHECK(ndr_pull_align(ndr, 4));
10936                 {
10937                         uint32_t _flags_save_string = ndr->flags;
10938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10939                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
10940                         if (_ptr_print_processor_name) {
10941                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
10942                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
10943                         } else {
10944                                 r->print_processor_name = NULL;
10945                         }
10946                         ndr->flags = _flags_save_string;
10947                 }
10948         }
10949         if (ndr_flags & NDR_BUFFERS) {
10950                 {
10951                         uint32_t _flags_save_string = ndr->flags;
10952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10953                         if (r->print_processor_name) {
10954                                 uint32_t _relative_save_offset;
10955                                 _relative_save_offset = ndr->offset;
10956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
10957                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10958                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
10959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
10960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
10961                                 ndr->offset = _relative_save_offset;
10962                         }
10963                         ndr->flags = _flags_save_string;
10964                 }
10965         }
10966         return NDR_ERR_SUCCESS;
10967 }
10968
10969 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
10970 {
10971         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
10972         ndr->depth++;
10973         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
10974         ndr->depth++;
10975         if (r->print_processor_name) {
10976                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
10977         }
10978         ndr->depth--;
10979         ndr->depth--;
10980 }
10981
10982 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
10983 {
10984         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10985         if (ndr_flags & NDR_SCALARS) {
10986                 int level = ndr_push_get_switch_value(ndr, r);
10987                 switch (level) {
10988                         case 1: {
10989                                 NDR_CHECK(ndr_push_align(ndr, 4));
10990                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10991                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
10992                         break; }
10993
10994                         default: {
10995                         break; }
10996
10997                 }
10998         }
10999         if (ndr_flags & NDR_BUFFERS) {
11000                 int level = ndr_push_get_switch_value(ndr, r);
11001                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11002                 switch (level) {
11003                         case 1:
11004                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11005                         break;
11006
11007                         default:
11008                         break;
11009
11010                 }
11011         }
11012         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11013         return NDR_ERR_SUCCESS;
11014 }
11015
11016 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
11017 {
11018         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11019         int level;
11020         level = ndr_pull_get_switch_value(ndr, r);
11021         if (ndr_flags & NDR_SCALARS) {
11022                 switch (level) {
11023                         case 1: {
11024                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11025                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11026                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11027                         break; }
11028
11029                         default: {
11030                         break; }
11031
11032                 }
11033         }
11034         if (ndr_flags & NDR_BUFFERS) {
11035                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11036                 switch (level) {
11037                         case 1:
11038                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11039                         break;
11040
11041                         default:
11042                         break;
11043
11044                 }
11045         }
11046         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11047         return NDR_ERR_SUCCESS;
11048 }
11049
11050 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
11051 {
11052         int level;
11053         level = ndr_print_get_switch_value(ndr, r);
11054         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
11055         switch (level) {
11056                 case 1:
11057                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
11058                 break;
11059
11060                 default:
11061                 break;
11062
11063         }
11064 }
11065
11066 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
11067 {
11068         if (ndr_flags & NDR_SCALARS) {
11069                 NDR_CHECK(ndr_push_align(ndr, 4));
11070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
11071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
11072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
11073         }
11074         if (ndr_flags & NDR_BUFFERS) {
11075                 if (r->document_name) {
11076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11079                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11080                 }
11081                 if (r->output_file) {
11082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11085                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11086                 }
11087                 if (r->datatype) {
11088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11091                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11092                 }
11093         }
11094         return NDR_ERR_SUCCESS;
11095 }
11096
11097 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
11098 {
11099         uint32_t _ptr_document_name;
11100         TALLOC_CTX *_mem_save_document_name_0;
11101         uint32_t _ptr_output_file;
11102         TALLOC_CTX *_mem_save_output_file_0;
11103         uint32_t _ptr_datatype;
11104         TALLOC_CTX *_mem_save_datatype_0;
11105         if (ndr_flags & NDR_SCALARS) {
11106                 NDR_CHECK(ndr_pull_align(ndr, 4));
11107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
11108                 if (_ptr_document_name) {
11109                         NDR_PULL_ALLOC(ndr, r->document_name);
11110                 } else {
11111                         r->document_name = NULL;
11112                 }
11113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
11114                 if (_ptr_output_file) {
11115                         NDR_PULL_ALLOC(ndr, r->output_file);
11116                 } else {
11117                         r->output_file = NULL;
11118                 }
11119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
11120                 if (_ptr_datatype) {
11121                         NDR_PULL_ALLOC(ndr, r->datatype);
11122                 } else {
11123                         r->datatype = NULL;
11124                 }
11125         }
11126         if (ndr_flags & NDR_BUFFERS) {
11127                 if (r->document_name) {
11128                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11129                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
11130                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
11131                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
11132                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
11133                                 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));
11134                         }
11135                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
11136                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
11137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
11138                 }
11139                 if (r->output_file) {
11140                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11141                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
11142                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
11143                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
11144                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
11145                                 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));
11146                         }
11147                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
11148                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
11149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
11150                 }
11151                 if (r->datatype) {
11152                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11153                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
11154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
11155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
11156                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
11157                                 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));
11158                         }
11159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
11160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
11161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
11162                 }
11163         }
11164         return NDR_ERR_SUCCESS;
11165 }
11166
11167 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
11168 {
11169         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
11170         ndr->depth++;
11171         ndr_print_ptr(ndr, "document_name", r->document_name);
11172         ndr->depth++;
11173         if (r->document_name) {
11174                 ndr_print_string(ndr, "document_name", r->document_name);
11175         }
11176         ndr->depth--;
11177         ndr_print_ptr(ndr, "output_file", r->output_file);
11178         ndr->depth++;
11179         if (r->output_file) {
11180                 ndr_print_string(ndr, "output_file", r->output_file);
11181         }
11182         ndr->depth--;
11183         ndr_print_ptr(ndr, "datatype", r->datatype);
11184         ndr->depth++;
11185         if (r->datatype) {
11186                 ndr_print_string(ndr, "datatype", r->datatype);
11187         }
11188         ndr->depth--;
11189         ndr->depth--;
11190 }
11191
11192 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
11193 {
11194         if (ndr_flags & NDR_SCALARS) {
11195                 int level = ndr_push_get_switch_value(ndr, r);
11196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11197                 switch (level) {
11198                         case 1: {
11199                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
11200                         break; }
11201
11202                         case 2: {
11203                         break; }
11204
11205                         case 3: {
11206                         break; }
11207
11208                         default: {
11209                         break; }
11210
11211                 }
11212         }
11213         if (ndr_flags & NDR_BUFFERS) {
11214                 int level = ndr_push_get_switch_value(ndr, r);
11215                 switch (level) {
11216                         case 1:
11217                                 if (r->info1) {
11218                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11219                                 }
11220                         break;
11221
11222                         case 2:
11223                         break;
11224
11225                         case 3:
11226                         break;
11227
11228                         default:
11229                         break;
11230
11231                 }
11232         }
11233         return NDR_ERR_SUCCESS;
11234 }
11235
11236 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
11237 {
11238         int level;
11239         uint32_t _level;
11240         TALLOC_CTX *_mem_save_info1_0;
11241         level = ndr_pull_get_switch_value(ndr, r);
11242         if (ndr_flags & NDR_SCALARS) {
11243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11244                 if (_level != level) {
11245                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11246                 }
11247                 switch (level) {
11248                         case 1: {
11249                                 uint32_t _ptr_info1;
11250                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
11251                                 if (_ptr_info1) {
11252                                         NDR_PULL_ALLOC(ndr, r->info1);
11253                                 } else {
11254                                         r->info1 = NULL;
11255                                 }
11256                         break; }
11257
11258                         case 2: {
11259                         break; }
11260
11261                         case 3: {
11262                         break; }
11263
11264                         default: {
11265                         break; }
11266
11267                 }
11268         }
11269         if (ndr_flags & NDR_BUFFERS) {
11270                 switch (level) {
11271                         case 1:
11272                                 if (r->info1) {
11273                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11274                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
11275                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11276                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
11277                                 }
11278                         break;
11279
11280                         case 2:
11281                         break;
11282
11283                         case 3:
11284                         break;
11285
11286                         default:
11287                         break;
11288
11289                 }
11290         }
11291         return NDR_ERR_SUCCESS;
11292 }
11293
11294 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
11295 {
11296         int level;
11297         level = ndr_print_get_switch_value(ndr, r);
11298         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
11299         switch (level) {
11300                 case 1:
11301                         ndr_print_ptr(ndr, "info1", r->info1);
11302                         ndr->depth++;
11303                         if (r->info1) {
11304                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
11305                         }
11306                         ndr->depth--;
11307                 break;
11308
11309                 case 2:
11310                 break;
11311
11312                 case 3:
11313                 break;
11314
11315                 default:
11316                 break;
11317
11318         }
11319 }
11320
11321 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
11322 {
11323         if (ndr_flags & NDR_SCALARS) {
11324                 NDR_CHECK(ndr_push_align(ndr, 4));
11325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
11326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11330                 {
11331                         uint32_t _flags_save_string = ndr->flags;
11332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11333                         {
11334                                 struct ndr_push *_ndr_extra_string;
11335                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11336                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11337                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11338                         }
11339                         ndr->flags = _flags_save_string;
11340                 }
11341         }
11342         if (ndr_flags & NDR_BUFFERS) {
11343         }
11344         return NDR_ERR_SUCCESS;
11345 }
11346
11347 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
11348 {
11349         if (ndr_flags & NDR_SCALARS) {
11350                 NDR_CHECK(ndr_pull_align(ndr, 4));
11351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
11356                 {
11357                         uint32_t _flags_save_string = ndr->flags;
11358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11359                         {
11360                                 struct ndr_pull *_ndr_extra_string;
11361                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11362                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11363                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11364                         }
11365                         ndr->flags = _flags_save_string;
11366                 }
11367         }
11368         if (ndr_flags & NDR_BUFFERS) {
11369         }
11370         return NDR_ERR_SUCCESS;
11371 }
11372
11373 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
11374 {
11375         ndr_print_struct(ndr, name, "spoolss_OSVersion");
11376         ndr->depth++;
11377         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);
11378         ndr_print_uint32(ndr, "major", r->major);
11379         ndr_print_uint32(ndr, "minor", r->minor);
11380         ndr_print_uint32(ndr, "build", r->build);
11381         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
11382         ndr_print_string(ndr, "extra_string", r->extra_string);
11383         ndr->depth--;
11384 }
11385
11386 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
11387 {
11388         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
11389 }
11390
11391 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
11392 {
11393         if (ndr_flags & NDR_SCALARS) {
11394                 NDR_CHECK(ndr_push_align(ndr, 4));
11395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
11396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11400                 {
11401                         uint32_t _flags_save_string = ndr->flags;
11402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11403                         {
11404                                 struct ndr_push *_ndr_extra_string;
11405                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11406                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11407                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11408                         }
11409                         ndr->flags = _flags_save_string;
11410                 }
11411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
11412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
11413         }
11414         if (ndr_flags & NDR_BUFFERS) {
11415         }
11416         return NDR_ERR_SUCCESS;
11417 }
11418
11419 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
11420 {
11421         if (ndr_flags & NDR_SCALARS) {
11422                 NDR_CHECK(ndr_pull_align(ndr, 4));
11423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
11428                 {
11429                         uint32_t _flags_save_string = ndr->flags;
11430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11431                         {
11432                                 struct ndr_pull *_ndr_extra_string;
11433                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11434                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11435                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11436                         }
11437                         ndr->flags = _flags_save_string;
11438                 }
11439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
11440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
11441         }
11442         if (ndr_flags & NDR_BUFFERS) {
11443         }
11444         return NDR_ERR_SUCCESS;
11445 }
11446
11447 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
11448 {
11449         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
11450         ndr->depth++;
11451         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);
11452         ndr_print_uint32(ndr, "major", r->major);
11453         ndr_print_uint32(ndr, "minor", r->minor);
11454         ndr_print_uint32(ndr, "build", r->build);
11455         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
11456         ndr_print_string(ndr, "extra_string", r->extra_string);
11457         ndr_print_uint32(ndr, "unknown2", r->unknown2);
11458         ndr_print_uint32(ndr, "unknown3", r->unknown3);
11459         ndr->depth--;
11460 }
11461
11462 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
11463 {
11464         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
11465 }
11466
11467 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
11468 {
11469         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11470         return NDR_ERR_SUCCESS;
11471 }
11472
11473 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
11474 {
11475         uint32_t v;
11476         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11477         *r = v;
11478         return NDR_ERR_SUCCESS;
11479 }
11480
11481 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
11482 {
11483         const char *val = NULL;
11484
11485         switch (r) {
11486                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
11487                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
11488                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
11489                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
11490                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
11491         }
11492         ndr_print_enum(ndr, name, "ENUM", val, r);
11493 }
11494
11495 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
11496 {
11497         if (ndr_flags & NDR_SCALARS) {
11498                 int level = ndr_push_get_switch_value(ndr, r);
11499                 switch (level) {
11500                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11501                         break; }
11502
11503                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11504                                 {
11505                                         uint32_t _flags_save_string = ndr->flags;
11506                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11507                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
11508                                         ndr->flags = _flags_save_string;
11509                                 }
11510                         break; }
11511
11512                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11513                                 {
11514                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11515                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11516                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11517                                         ndr->flags = _flags_save_DATA_BLOB;
11518                                 }
11519                         break; }
11520
11521                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11522                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
11523                         break; }
11524
11525                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11526                                 {
11527                                         uint32_t _flags_save_string_array = ndr->flags;
11528                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11529                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
11530                                         ndr->flags = _flags_save_string_array;
11531                                 }
11532                         break; }
11533
11534                         default: {
11535                                 {
11536                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11537                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11538                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
11539                                         ndr->flags = _flags_save_DATA_BLOB;
11540                                 }
11541                         break; }
11542
11543                 }
11544         }
11545         if (ndr_flags & NDR_BUFFERS) {
11546                 int level = ndr_push_get_switch_value(ndr, r);
11547                 switch (level) {
11548                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11549                         break;
11550
11551                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11552                         break;
11553
11554                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11555                         break;
11556
11557                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11558                         break;
11559
11560                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11561                         break;
11562
11563                         default:
11564                         break;
11565
11566                 }
11567         }
11568         return NDR_ERR_SUCCESS;
11569 }
11570
11571 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
11572 {
11573         int level;
11574         level = ndr_pull_get_switch_value(ndr, r);
11575         if (ndr_flags & NDR_SCALARS) {
11576                 switch (level) {
11577                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11578                         break; }
11579
11580                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11581                                 {
11582                                         uint32_t _flags_save_string = ndr->flags;
11583                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11584                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
11585                                         ndr->flags = _flags_save_string;
11586                                 }
11587                         break; }
11588
11589                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11590                                 {
11591                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11592                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11593                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
11594                                         ndr->flags = _flags_save_DATA_BLOB;
11595                                 }
11596                         break; }
11597
11598                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11599                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
11600                         break; }
11601
11602                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11603                                 {
11604                                         uint32_t _flags_save_string_array = ndr->flags;
11605                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11606                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
11607                                         ndr->flags = _flags_save_string_array;
11608                                 }
11609                         break; }
11610
11611                         default: {
11612                                 {
11613                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11614                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11615                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
11616                                         ndr->flags = _flags_save_DATA_BLOB;
11617                                 }
11618                         break; }
11619
11620                 }
11621         }
11622         if (ndr_flags & NDR_BUFFERS) {
11623                 switch (level) {
11624                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11625                         break;
11626
11627                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11628                         break;
11629
11630                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11631                         break;
11632
11633                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11634                         break;
11635
11636                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11637                         break;
11638
11639                         default:
11640                         break;
11641
11642                 }
11643         }
11644         return NDR_ERR_SUCCESS;
11645 }
11646
11647 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
11648 {
11649         int level;
11650         level = ndr_print_get_switch_value(ndr, r);
11651         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
11652         switch (level) {
11653                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11654                 break;
11655
11656                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11657                         ndr_print_string(ndr, "string", r->string);
11658                 break;
11659
11660                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11661                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
11662                 break;
11663
11664                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11665                         ndr_print_uint32(ndr, "value", r->value);
11666                 break;
11667
11668                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11669                         ndr_print_string_array(ndr, "string_array", r->string_array);
11670                 break;
11671
11672                 default:
11673                         ndr_print_DATA_BLOB(ndr, "data", r->data);
11674                 break;
11675
11676         }
11677 }
11678
11679 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11680 {
11681         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
11682 }
11683
11684 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
11685 {
11686         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11687         return NDR_ERR_SUCCESS;
11688 }
11689
11690 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
11691 {
11692         uint32_t v;
11693         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11694         *r = v;
11695         return NDR_ERR_SUCCESS;
11696 }
11697
11698 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
11699 {
11700         const char *val = NULL;
11701
11702         switch (r) {
11703                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
11704                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
11705                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
11706         }
11707         ndr_print_enum(ndr, name, "ENUM", val, r);
11708 }
11709
11710 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
11711 {
11712         if (ndr_flags & NDR_SCALARS) {
11713                 NDR_CHECK(ndr_push_align(ndr, 4));
11714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
11715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
11716         }
11717         if (ndr_flags & NDR_BUFFERS) {
11718         }
11719         return NDR_ERR_SUCCESS;
11720 }
11721
11722 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
11723 {
11724         if (ndr_flags & NDR_SCALARS) {
11725                 NDR_CHECK(ndr_pull_align(ndr, 4));
11726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
11727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
11728         }
11729         if (ndr_flags & NDR_BUFFERS) {
11730         }
11731         return NDR_ERR_SUCCESS;
11732 }
11733
11734 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
11735 {
11736         ndr_print_struct(ndr, name, "spoolss_FormSize");
11737         ndr->depth++;
11738         ndr_print_uint32(ndr, "width", r->width);
11739         ndr_print_uint32(ndr, "height", r->height);
11740         ndr->depth--;
11741 }
11742
11743 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
11744 {
11745         if (ndr_flags & NDR_SCALARS) {
11746                 NDR_CHECK(ndr_push_align(ndr, 4));
11747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
11748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
11749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
11750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
11751         }
11752         if (ndr_flags & NDR_BUFFERS) {
11753         }
11754         return NDR_ERR_SUCCESS;
11755 }
11756
11757 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
11758 {
11759         if (ndr_flags & NDR_SCALARS) {
11760                 NDR_CHECK(ndr_pull_align(ndr, 4));
11761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
11762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
11763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
11764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
11765         }
11766         if (ndr_flags & NDR_BUFFERS) {
11767         }
11768         return NDR_ERR_SUCCESS;
11769 }
11770
11771 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
11772 {
11773         ndr_print_struct(ndr, name, "spoolss_FormArea");
11774         ndr->depth++;
11775         ndr_print_uint32(ndr, "left", r->left);
11776         ndr_print_uint32(ndr, "top", r->top);
11777         ndr_print_uint32(ndr, "right", r->right);
11778         ndr_print_uint32(ndr, "bottom", r->bottom);
11779         ndr->depth--;
11780 }
11781
11782 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
11783 {
11784         if (ndr_flags & NDR_SCALARS) {
11785                 NDR_CHECK(ndr_push_align(ndr, 4));
11786                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
11787                 {
11788                         uint32_t _flags_save_string = ndr->flags;
11789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11790                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
11791                         ndr->flags = _flags_save_string;
11792                 }
11793                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11794                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11795         }
11796         if (ndr_flags & NDR_BUFFERS) {
11797                 {
11798                         uint32_t _flags_save_string = ndr->flags;
11799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11800                         if (r->form_name) {
11801                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
11802                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
11803                         }
11804                         ndr->flags = _flags_save_string;
11805                 }
11806         }
11807         return NDR_ERR_SUCCESS;
11808 }
11809
11810 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
11811 {
11812         uint32_t _ptr_form_name;
11813         TALLOC_CTX *_mem_save_form_name_0;
11814         if (ndr_flags & NDR_SCALARS) {
11815                 NDR_CHECK(ndr_pull_align(ndr, 4));
11816                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
11817                 {
11818                         uint32_t _flags_save_string = ndr->flags;
11819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11820                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
11821                         if (_ptr_form_name) {
11822                                 NDR_PULL_ALLOC(ndr, r->form_name);
11823                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
11824                         } else {
11825                                 r->form_name = NULL;
11826                         }
11827                         ndr->flags = _flags_save_string;
11828                 }
11829                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11830                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11831         }
11832         if (ndr_flags & NDR_BUFFERS) {
11833                 {
11834                         uint32_t _flags_save_string = ndr->flags;
11835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11836                         if (r->form_name) {
11837                                 uint32_t _relative_save_offset;
11838                                 _relative_save_offset = ndr->offset;
11839                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
11840                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11841                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
11842                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
11843                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
11844                                 ndr->offset = _relative_save_offset;
11845                         }
11846                         ndr->flags = _flags_save_string;
11847                 }
11848         }
11849         return NDR_ERR_SUCCESS;
11850 }
11851
11852 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
11853 {
11854         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
11855         ndr->depth++;
11856         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
11857         ndr_print_ptr(ndr, "form_name", r->form_name);
11858         ndr->depth++;
11859         if (r->form_name) {
11860                 ndr_print_string(ndr, "form_name", r->form_name);
11861         }
11862         ndr->depth--;
11863         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
11864         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
11865         ndr->depth--;
11866 }
11867
11868 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
11869 {
11870         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11871         if (ndr_flags & NDR_SCALARS) {
11872                 int level = ndr_push_get_switch_value(ndr, r);
11873                 switch (level) {
11874                         case 1: {
11875                                 NDR_CHECK(ndr_push_align(ndr, 4));
11876                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11877                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
11878                         break; }
11879
11880                         default: {
11881                         break; }
11882
11883                 }
11884         }
11885         if (ndr_flags & NDR_BUFFERS) {
11886                 int level = ndr_push_get_switch_value(ndr, r);
11887                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11888                 switch (level) {
11889                         case 1:
11890                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
11891                         break;
11892
11893                         default:
11894                         break;
11895
11896                 }
11897         }
11898         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11899         return NDR_ERR_SUCCESS;
11900 }
11901
11902 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
11903 {
11904         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11905         int level;
11906         level = ndr_pull_get_switch_value(ndr, r);
11907         if (ndr_flags & NDR_SCALARS) {
11908                 switch (level) {
11909                         case 1: {
11910                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11911                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11912                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
11913                         break; }
11914
11915                         default: {
11916                         break; }
11917
11918                 }
11919         }
11920         if (ndr_flags & NDR_BUFFERS) {
11921                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11922                 switch (level) {
11923                         case 1:
11924                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
11925                         break;
11926
11927                         default:
11928                         break;
11929
11930                 }
11931         }
11932         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11933         return NDR_ERR_SUCCESS;
11934 }
11935
11936 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
11937 {
11938         int level;
11939         level = ndr_print_get_switch_value(ndr, r);
11940         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
11941         switch (level) {
11942                 case 1:
11943                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
11944                 break;
11945
11946                 default:
11947                 break;
11948
11949         }
11950 }
11951
11952 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11953 {
11954         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
11955 }
11956
11957 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
11958 {
11959         if (ndr_flags & NDR_SCALARS) {
11960                 NDR_CHECK(ndr_push_align(ndr, 4));
11961                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
11962                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
11963                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11964                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11965         }
11966         if (ndr_flags & NDR_BUFFERS) {
11967                 if (r->form_name) {
11968                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
11969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11970                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
11971                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11972                 }
11973         }
11974         return NDR_ERR_SUCCESS;
11975 }
11976
11977 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
11978 {
11979         uint32_t _ptr_form_name;
11980         TALLOC_CTX *_mem_save_form_name_0;
11981         if (ndr_flags & NDR_SCALARS) {
11982                 NDR_CHECK(ndr_pull_align(ndr, 4));
11983                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
11984                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
11985                 if (_ptr_form_name) {
11986                         NDR_PULL_ALLOC(ndr, r->form_name);
11987                 } else {
11988                         r->form_name = NULL;
11989                 }
11990                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11991                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11992         }
11993         if (ndr_flags & NDR_BUFFERS) {
11994                 if (r->form_name) {
11995                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11996                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
11997                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
11998                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
11999                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
12000                                 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));
12001                         }
12002                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
12003                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
12004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12005                 }
12006         }
12007         return NDR_ERR_SUCCESS;
12008 }
12009
12010 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
12011 {
12012         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
12013         ndr->depth++;
12014         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12015         ndr_print_ptr(ndr, "form_name", r->form_name);
12016         ndr->depth++;
12017         if (r->form_name) {
12018                 ndr_print_string(ndr, "form_name", r->form_name);
12019         }
12020         ndr->depth--;
12021         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12022         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12023         ndr->depth--;
12024 }
12025
12026 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
12027 {
12028         if (ndr_flags & NDR_SCALARS) {
12029                 int level = ndr_push_get_switch_value(ndr, r);
12030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12031                 switch (level) {
12032                         case 1: {
12033                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
12034                         break; }
12035
12036                         default:
12037                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12038                 }
12039         }
12040         if (ndr_flags & NDR_BUFFERS) {
12041                 int level = ndr_push_get_switch_value(ndr, r);
12042                 switch (level) {
12043                         case 1:
12044                                 if (r->info1) {
12045                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12046                                 }
12047                         break;
12048
12049                         default:
12050                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12051                 }
12052         }
12053         return NDR_ERR_SUCCESS;
12054 }
12055
12056 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
12057 {
12058         int level;
12059         uint32_t _level;
12060         TALLOC_CTX *_mem_save_info1_0;
12061         level = ndr_pull_get_switch_value(ndr, r);
12062         if (ndr_flags & NDR_SCALARS) {
12063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12064                 if (_level != level) {
12065                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12066                 }
12067                 switch (level) {
12068                         case 1: {
12069                                 uint32_t _ptr_info1;
12070                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
12071                                 if (_ptr_info1) {
12072                                         NDR_PULL_ALLOC(ndr, r->info1);
12073                                 } else {
12074                                         r->info1 = NULL;
12075                                 }
12076                         break; }
12077
12078                         default:
12079                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12080                 }
12081         }
12082         if (ndr_flags & NDR_BUFFERS) {
12083                 switch (level) {
12084                         case 1:
12085                                 if (r->info1) {
12086                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12087                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
12088                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12089                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
12090                                 }
12091                         break;
12092
12093                         default:
12094                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12095                 }
12096         }
12097         return NDR_ERR_SUCCESS;
12098 }
12099
12100 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
12101 {
12102         int level;
12103         level = ndr_print_get_switch_value(ndr, r);
12104         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
12105         switch (level) {
12106                 case 1:
12107                         ndr_print_ptr(ndr, "info1", r->info1);
12108                         ndr->depth++;
12109                         if (r->info1) {
12110                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
12111                         }
12112                         ndr->depth--;
12113                 break;
12114
12115                 default:
12116                         ndr_print_bad_level(ndr, name, level);
12117         }
12118 }
12119
12120 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
12121 {
12122         if (ndr_flags & NDR_SCALARS) {
12123                 NDR_CHECK(ndr_push_align(ndr, 4));
12124                 {
12125                         uint32_t _flags_save_string = ndr->flags;
12126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12127                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12128                         ndr->flags = _flags_save_string;
12129                 }
12130         }
12131         if (ndr_flags & NDR_BUFFERS) {
12132                 {
12133                         uint32_t _flags_save_string = ndr->flags;
12134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12135                         if (r->port_name) {
12136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12138                         }
12139                         ndr->flags = _flags_save_string;
12140                 }
12141         }
12142         return NDR_ERR_SUCCESS;
12143 }
12144
12145 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
12146 {
12147         uint32_t _ptr_port_name;
12148         TALLOC_CTX *_mem_save_port_name_0;
12149         if (ndr_flags & NDR_SCALARS) {
12150                 NDR_CHECK(ndr_pull_align(ndr, 4));
12151                 {
12152                         uint32_t _flags_save_string = ndr->flags;
12153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12155                         if (_ptr_port_name) {
12156                                 NDR_PULL_ALLOC(ndr, r->port_name);
12157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12158                         } else {
12159                                 r->port_name = NULL;
12160                         }
12161                         ndr->flags = _flags_save_string;
12162                 }
12163         }
12164         if (ndr_flags & NDR_BUFFERS) {
12165                 {
12166                         uint32_t _flags_save_string = ndr->flags;
12167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12168                         if (r->port_name) {
12169                                 uint32_t _relative_save_offset;
12170                                 _relative_save_offset = ndr->offset;
12171                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12172                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12173                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12174                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12175                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12176                                 ndr->offset = _relative_save_offset;
12177                         }
12178                         ndr->flags = _flags_save_string;
12179                 }
12180         }
12181         return NDR_ERR_SUCCESS;
12182 }
12183
12184 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
12185 {
12186         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
12187         ndr->depth++;
12188         ndr_print_ptr(ndr, "port_name", r->port_name);
12189         ndr->depth++;
12190         if (r->port_name) {
12191                 ndr_print_string(ndr, "port_name", r->port_name);
12192         }
12193         ndr->depth--;
12194         ndr->depth--;
12195 }
12196
12197 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12198 {
12199         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12200         return NDR_ERR_SUCCESS;
12201 }
12202
12203 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12204 {
12205         uint32_t v;
12206         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12207         *r = v;
12208         return NDR_ERR_SUCCESS;
12209 }
12210
12211 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
12212 {
12213         ndr_print_uint32(ndr, name, r);
12214         ndr->depth++;
12215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
12216         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
12217         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
12218         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
12219         ndr->depth--;
12220 }
12221
12222 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
12223 {
12224         if (ndr_flags & NDR_SCALARS) {
12225                 NDR_CHECK(ndr_push_align(ndr, 4));
12226                 {
12227                         uint32_t _flags_save_string = ndr->flags;
12228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12230                         ndr->flags = _flags_save_string;
12231                 }
12232                 {
12233                         uint32_t _flags_save_string = ndr->flags;
12234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12235                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12236                         ndr->flags = _flags_save_string;
12237                 }
12238                 {
12239                         uint32_t _flags_save_string = ndr->flags;
12240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
12242                         ndr->flags = _flags_save_string;
12243                 }
12244                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
12245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12246         }
12247         if (ndr_flags & NDR_BUFFERS) {
12248                 {
12249                         uint32_t _flags_save_string = ndr->flags;
12250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12251                         if (r->port_name) {
12252                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12253                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12254                         }
12255                         ndr->flags = _flags_save_string;
12256                 }
12257                 {
12258                         uint32_t _flags_save_string = ndr->flags;
12259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12260                         if (r->monitor_name) {
12261                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12262                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12263                         }
12264                         ndr->flags = _flags_save_string;
12265                 }
12266                 {
12267                         uint32_t _flags_save_string = ndr->flags;
12268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12269                         if (r->description) {
12270                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
12271                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
12272                         }
12273                         ndr->flags = _flags_save_string;
12274                 }
12275         }
12276         return NDR_ERR_SUCCESS;
12277 }
12278
12279 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
12280 {
12281         uint32_t _ptr_port_name;
12282         TALLOC_CTX *_mem_save_port_name_0;
12283         uint32_t _ptr_monitor_name;
12284         TALLOC_CTX *_mem_save_monitor_name_0;
12285         uint32_t _ptr_description;
12286         TALLOC_CTX *_mem_save_description_0;
12287         if (ndr_flags & NDR_SCALARS) {
12288                 NDR_CHECK(ndr_pull_align(ndr, 4));
12289                 {
12290                         uint32_t _flags_save_string = ndr->flags;
12291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12292                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12293                         if (_ptr_port_name) {
12294                                 NDR_PULL_ALLOC(ndr, r->port_name);
12295                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12296                         } else {
12297                                 r->port_name = NULL;
12298                         }
12299                         ndr->flags = _flags_save_string;
12300                 }
12301                 {
12302                         uint32_t _flags_save_string = ndr->flags;
12303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12304                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12305                         if (_ptr_monitor_name) {
12306                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12307                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12308                         } else {
12309                                 r->monitor_name = NULL;
12310                         }
12311                         ndr->flags = _flags_save_string;
12312                 }
12313                 {
12314                         uint32_t _flags_save_string = ndr->flags;
12315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12316                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
12317                         if (_ptr_description) {
12318                                 NDR_PULL_ALLOC(ndr, r->description);
12319                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
12320                         } else {
12321                                 r->description = NULL;
12322                         }
12323                         ndr->flags = _flags_save_string;
12324                 }
12325                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
12326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12327         }
12328         if (ndr_flags & NDR_BUFFERS) {
12329                 {
12330                         uint32_t _flags_save_string = ndr->flags;
12331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12332                         if (r->port_name) {
12333                                 uint32_t _relative_save_offset;
12334                                 _relative_save_offset = ndr->offset;
12335                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12336                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12337                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12338                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12339                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12340                                 ndr->offset = _relative_save_offset;
12341                         }
12342                         ndr->flags = _flags_save_string;
12343                 }
12344                 {
12345                         uint32_t _flags_save_string = ndr->flags;
12346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12347                         if (r->monitor_name) {
12348                                 uint32_t _relative_save_offset;
12349                                 _relative_save_offset = ndr->offset;
12350                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12351                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12352                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12353                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12354                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12355                                 ndr->offset = _relative_save_offset;
12356                         }
12357                         ndr->flags = _flags_save_string;
12358                 }
12359                 {
12360                         uint32_t _flags_save_string = ndr->flags;
12361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12362                         if (r->description) {
12363                                 uint32_t _relative_save_offset;
12364                                 _relative_save_offset = ndr->offset;
12365                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
12366                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
12367                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
12368                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
12369                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
12370                                 ndr->offset = _relative_save_offset;
12371                         }
12372                         ndr->flags = _flags_save_string;
12373                 }
12374         }
12375         return NDR_ERR_SUCCESS;
12376 }
12377
12378 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
12379 {
12380         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
12381         ndr->depth++;
12382         ndr_print_ptr(ndr, "port_name", r->port_name);
12383         ndr->depth++;
12384         if (r->port_name) {
12385                 ndr_print_string(ndr, "port_name", r->port_name);
12386         }
12387         ndr->depth--;
12388         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12389         ndr->depth++;
12390         if (r->monitor_name) {
12391                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12392         }
12393         ndr->depth--;
12394         ndr_print_ptr(ndr, "description", r->description);
12395         ndr->depth++;
12396         if (r->description) {
12397                 ndr_print_string(ndr, "description", r->description);
12398         }
12399         ndr->depth--;
12400         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
12401         ndr_print_uint32(ndr, "reserved", r->reserved);
12402         ndr->depth--;
12403 }
12404
12405 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
12406 {
12407         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12408         if (ndr_flags & NDR_SCALARS) {
12409                 int level = ndr_push_get_switch_value(ndr, r);
12410                 switch (level) {
12411                         case 1: {
12412                                 NDR_CHECK(ndr_push_align(ndr, 4));
12413                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12414                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12415                         break; }
12416
12417                         case 2: {
12418                                 NDR_CHECK(ndr_push_align(ndr, 4));
12419                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12420                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12421                         break; }
12422
12423                         case 3: {
12424                         break; }
12425
12426                         default: {
12427                         break; }
12428
12429                 }
12430         }
12431         if (ndr_flags & NDR_BUFFERS) {
12432                 int level = ndr_push_get_switch_value(ndr, r);
12433                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12434                 switch (level) {
12435                         case 1:
12436                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12437                         break;
12438
12439                         case 2:
12440                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12441                         break;
12442
12443                         case 3:
12444                         break;
12445
12446                         default:
12447                         break;
12448
12449                 }
12450         }
12451         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12452         return NDR_ERR_SUCCESS;
12453 }
12454
12455 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
12456 {
12457         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12458         int level;
12459         level = ndr_pull_get_switch_value(ndr, r);
12460         if (ndr_flags & NDR_SCALARS) {
12461                 switch (level) {
12462                         case 1: {
12463                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12464                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12465                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12466                         break; }
12467
12468                         case 2: {
12469                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12470                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12471                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12472                         break; }
12473
12474                         case 3: {
12475                         break; }
12476
12477                         default: {
12478                         break; }
12479
12480                 }
12481         }
12482         if (ndr_flags & NDR_BUFFERS) {
12483                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12484                 switch (level) {
12485                         case 1:
12486                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12487                         break;
12488
12489                         case 2:
12490                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12491                         break;
12492
12493                         case 3:
12494                         break;
12495
12496                         default:
12497                         break;
12498
12499                 }
12500         }
12501         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12502         return NDR_ERR_SUCCESS;
12503 }
12504
12505 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
12506 {
12507         int level;
12508         level = ndr_print_get_switch_value(ndr, r);
12509         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
12510         switch (level) {
12511                 case 1:
12512                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
12513                 break;
12514
12515                 case 2:
12516                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
12517                 break;
12518
12519                 case 3:
12520                 break;
12521
12522                 default:
12523                 break;
12524
12525         }
12526 }
12527
12528 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
12529 {
12530         if (ndr_flags & NDR_SCALARS) {
12531                 NDR_CHECK(ndr_push_align(ndr, 4));
12532                 {
12533                         uint32_t _flags_save_string = ndr->flags;
12534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12536                         ndr->flags = _flags_save_string;
12537                 }
12538         }
12539         if (ndr_flags & NDR_BUFFERS) {
12540                 {
12541                         uint32_t _flags_save_string = ndr->flags;
12542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12543                         if (r->monitor_name) {
12544                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12545                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12546                         }
12547                         ndr->flags = _flags_save_string;
12548                 }
12549         }
12550         return NDR_ERR_SUCCESS;
12551 }
12552
12553 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
12554 {
12555         uint32_t _ptr_monitor_name;
12556         TALLOC_CTX *_mem_save_monitor_name_0;
12557         if (ndr_flags & NDR_SCALARS) {
12558                 NDR_CHECK(ndr_pull_align(ndr, 4));
12559                 {
12560                         uint32_t _flags_save_string = ndr->flags;
12561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12562                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12563                         if (_ptr_monitor_name) {
12564                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12565                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12566                         } else {
12567                                 r->monitor_name = NULL;
12568                         }
12569                         ndr->flags = _flags_save_string;
12570                 }
12571         }
12572         if (ndr_flags & NDR_BUFFERS) {
12573                 {
12574                         uint32_t _flags_save_string = ndr->flags;
12575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12576                         if (r->monitor_name) {
12577                                 uint32_t _relative_save_offset;
12578                                 _relative_save_offset = ndr->offset;
12579                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12580                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12581                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12582                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12583                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12584                                 ndr->offset = _relative_save_offset;
12585                         }
12586                         ndr->flags = _flags_save_string;
12587                 }
12588         }
12589         return NDR_ERR_SUCCESS;
12590 }
12591
12592 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
12593 {
12594         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
12595         ndr->depth++;
12596         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12597         ndr->depth++;
12598         if (r->monitor_name) {
12599                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12600         }
12601         ndr->depth--;
12602         ndr->depth--;
12603 }
12604
12605 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
12606 {
12607         if (ndr_flags & NDR_SCALARS) {
12608                 NDR_CHECK(ndr_push_align(ndr, 4));
12609                 {
12610                         uint32_t _flags_save_string = ndr->flags;
12611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12612                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12613                         ndr->flags = _flags_save_string;
12614                 }
12615                 {
12616                         uint32_t _flags_save_string = ndr->flags;
12617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12618                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
12619                         ndr->flags = _flags_save_string;
12620                 }
12621                 {
12622                         uint32_t _flags_save_string = ndr->flags;
12623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12624                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
12625                         ndr->flags = _flags_save_string;
12626                 }
12627         }
12628         if (ndr_flags & NDR_BUFFERS) {
12629                 {
12630                         uint32_t _flags_save_string = ndr->flags;
12631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12632                         if (r->monitor_name) {
12633                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12634                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12635                         }
12636                         ndr->flags = _flags_save_string;
12637                 }
12638                 {
12639                         uint32_t _flags_save_string = ndr->flags;
12640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12641                         if (r->environment) {
12642                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
12643                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
12644                         }
12645                         ndr->flags = _flags_save_string;
12646                 }
12647                 {
12648                         uint32_t _flags_save_string = ndr->flags;
12649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12650                         if (r->dll_name) {
12651                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
12652                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
12653                         }
12654                         ndr->flags = _flags_save_string;
12655                 }
12656         }
12657         return NDR_ERR_SUCCESS;
12658 }
12659
12660 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
12661 {
12662         uint32_t _ptr_monitor_name;
12663         TALLOC_CTX *_mem_save_monitor_name_0;
12664         uint32_t _ptr_environment;
12665         TALLOC_CTX *_mem_save_environment_0;
12666         uint32_t _ptr_dll_name;
12667         TALLOC_CTX *_mem_save_dll_name_0;
12668         if (ndr_flags & NDR_SCALARS) {
12669                 NDR_CHECK(ndr_pull_align(ndr, 4));
12670                 {
12671                         uint32_t _flags_save_string = ndr->flags;
12672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12673                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12674                         if (_ptr_monitor_name) {
12675                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12676                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12677                         } else {
12678                                 r->monitor_name = NULL;
12679                         }
12680                         ndr->flags = _flags_save_string;
12681                 }
12682                 {
12683                         uint32_t _flags_save_string = ndr->flags;
12684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12685                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
12686                         if (_ptr_environment) {
12687                                 NDR_PULL_ALLOC(ndr, r->environment);
12688                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
12689                         } else {
12690                                 r->environment = NULL;
12691                         }
12692                         ndr->flags = _flags_save_string;
12693                 }
12694                 {
12695                         uint32_t _flags_save_string = ndr->flags;
12696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12697                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
12698                         if (_ptr_dll_name) {
12699                                 NDR_PULL_ALLOC(ndr, r->dll_name);
12700                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
12701                         } else {
12702                                 r->dll_name = NULL;
12703                         }
12704                         ndr->flags = _flags_save_string;
12705                 }
12706         }
12707         if (ndr_flags & NDR_BUFFERS) {
12708                 {
12709                         uint32_t _flags_save_string = ndr->flags;
12710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12711                         if (r->monitor_name) {
12712                                 uint32_t _relative_save_offset;
12713                                 _relative_save_offset = ndr->offset;
12714                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12715                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12716                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12717                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12718                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12719                                 ndr->offset = _relative_save_offset;
12720                         }
12721                         ndr->flags = _flags_save_string;
12722                 }
12723                 {
12724                         uint32_t _flags_save_string = ndr->flags;
12725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12726                         if (r->environment) {
12727                                 uint32_t _relative_save_offset;
12728                                 _relative_save_offset = ndr->offset;
12729                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
12730                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
12731                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
12732                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
12733                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
12734                                 ndr->offset = _relative_save_offset;
12735                         }
12736                         ndr->flags = _flags_save_string;
12737                 }
12738                 {
12739                         uint32_t _flags_save_string = ndr->flags;
12740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12741                         if (r->dll_name) {
12742                                 uint32_t _relative_save_offset;
12743                                 _relative_save_offset = ndr->offset;
12744                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
12745                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12746                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
12747                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
12748                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
12749                                 ndr->offset = _relative_save_offset;
12750                         }
12751                         ndr->flags = _flags_save_string;
12752                 }
12753         }
12754         return NDR_ERR_SUCCESS;
12755 }
12756
12757 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
12758 {
12759         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
12760         ndr->depth++;
12761         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12762         ndr->depth++;
12763         if (r->monitor_name) {
12764                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12765         }
12766         ndr->depth--;
12767         ndr_print_ptr(ndr, "environment", r->environment);
12768         ndr->depth++;
12769         if (r->environment) {
12770                 ndr_print_string(ndr, "environment", r->environment);
12771         }
12772         ndr->depth--;
12773         ndr_print_ptr(ndr, "dll_name", r->dll_name);
12774         ndr->depth++;
12775         if (r->dll_name) {
12776                 ndr_print_string(ndr, "dll_name", r->dll_name);
12777         }
12778         ndr->depth--;
12779         ndr->depth--;
12780 }
12781
12782 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
12783 {
12784         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12785         if (ndr_flags & NDR_SCALARS) {
12786                 int level = ndr_push_get_switch_value(ndr, r);
12787                 switch (level) {
12788                         case 1: {
12789                                 NDR_CHECK(ndr_push_align(ndr, 4));
12790                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12791                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12792                         break; }
12793
12794                         case 2: {
12795                                 NDR_CHECK(ndr_push_align(ndr, 4));
12796                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12797                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12798                         break; }
12799
12800                         default: {
12801                         break; }
12802
12803                 }
12804         }
12805         if (ndr_flags & NDR_BUFFERS) {
12806                 int level = ndr_push_get_switch_value(ndr, r);
12807                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12808                 switch (level) {
12809                         case 1:
12810                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12811                         break;
12812
12813                         case 2:
12814                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12815                         break;
12816
12817                         default:
12818                         break;
12819
12820                 }
12821         }
12822         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12823         return NDR_ERR_SUCCESS;
12824 }
12825
12826 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
12827 {
12828         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12829         int level;
12830         level = ndr_pull_get_switch_value(ndr, r);
12831         if (ndr_flags & NDR_SCALARS) {
12832                 switch (level) {
12833                         case 1: {
12834                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12835                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12836                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12837                         break; }
12838
12839                         case 2: {
12840                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12841                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12842                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12843                         break; }
12844
12845                         default: {
12846                         break; }
12847
12848                 }
12849         }
12850         if (ndr_flags & NDR_BUFFERS) {
12851                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12852                 switch (level) {
12853                         case 1:
12854                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12855                         break;
12856
12857                         case 2:
12858                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12859                         break;
12860
12861                         default:
12862                         break;
12863
12864                 }
12865         }
12866         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12867         return NDR_ERR_SUCCESS;
12868 }
12869
12870 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
12871 {
12872         int level;
12873         level = ndr_print_get_switch_value(ndr, r);
12874         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
12875         switch (level) {
12876                 case 1:
12877                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
12878                 break;
12879
12880                 case 2:
12881                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
12882                 break;
12883
12884                 default:
12885                 break;
12886
12887         }
12888 }
12889
12890 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12891 {
12892         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12893         return NDR_ERR_SUCCESS;
12894 }
12895
12896 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12897 {
12898         uint32_t v;
12899         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12900         *r = v;
12901         return NDR_ERR_SUCCESS;
12902 }
12903
12904 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
12905 {
12906         ndr_print_uint32(ndr, name, r);
12907         ndr->depth++;
12908         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
12909         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
12910         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
12911         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
12912         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
12913         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
12914         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
12915         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
12916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
12917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
12918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
12919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
12920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
12921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
12922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
12923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
12924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
12925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
12926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
12927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
12928         ndr->depth--;
12929 }
12930
12931 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
12932 {
12933         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
12934         return NDR_ERR_SUCCESS;
12935 }
12936
12937 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
12938 {
12939         uint16_t v;
12940         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
12941         *r = v;
12942         return NDR_ERR_SUCCESS;
12943 }
12944
12945 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
12946 {
12947         const char *val = NULL;
12948
12949         switch (r) {
12950                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
12951                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
12952                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
12953                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
12954                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
12955                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
12956                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
12957                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
12958                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
12959                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
12960                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
12961                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
12962                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
12963                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
12964                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
12965                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
12966                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
12967                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
12968                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
12969                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
12970                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
12971                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
12972                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
12973                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
12974                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
12975                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
12976         }
12977         ndr_print_enum(ndr, name, "ENUM", val, r);
12978 }
12979
12980 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
12981 {
12982         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
12983         return NDR_ERR_SUCCESS;
12984 }
12985
12986 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
12987 {
12988         uint16_t v;
12989         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
12990         *r = v;
12991         return NDR_ERR_SUCCESS;
12992 }
12993
12994 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
12995 {
12996         const char *val = NULL;
12997
12998         switch (r) {
12999                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
13000                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
13001         }
13002         ndr_print_enum(ndr, name, "ENUM", val, r);
13003 }
13004
13005 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
13006 {
13007         uint32_t cntr_fields_1;
13008         if (ndr_flags & NDR_SCALARS) {
13009                 NDR_CHECK(ndr_push_align(ndr, 4));
13010                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13011                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
13012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
13013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
13014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
13016         }
13017         if (ndr_flags & NDR_BUFFERS) {
13018                 if (r->fields) {
13019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13020                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13021                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
13022                         }
13023                 }
13024         }
13025         return NDR_ERR_SUCCESS;
13026 }
13027
13028 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
13029 {
13030         uint32_t _ptr_fields;
13031         uint32_t cntr_fields_1;
13032         TALLOC_CTX *_mem_save_fields_0;
13033         TALLOC_CTX *_mem_save_fields_1;
13034         if (ndr_flags & NDR_SCALARS) {
13035                 NDR_CHECK(ndr_pull_align(ndr, 4));
13036                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13037                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
13038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
13039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
13040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
13042                 if (_ptr_fields) {
13043                         NDR_PULL_ALLOC(ndr, r->fields);
13044                 } else {
13045                         r->fields = NULL;
13046                 }
13047         }
13048         if (ndr_flags & NDR_BUFFERS) {
13049                 if (r->fields) {
13050                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
13051                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13052                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
13053                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
13054                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
13055                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13056                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13057                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
13058                         }
13059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
13060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
13061                 }
13062                 if (r->fields) {
13063                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
13064                 }
13065         }
13066         return NDR_ERR_SUCCESS;
13067 }
13068
13069 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
13070 {
13071         uint32_t cntr_fields_1;
13072         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
13073         ndr->depth++;
13074         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13075         ndr_print_uint16(ndr, "u1", r->u1);
13076         ndr_print_uint32(ndr, "u2", r->u2);
13077         ndr_print_uint32(ndr, "u3", r->u3);
13078         ndr_print_uint32(ndr, "count", r->count);
13079         ndr_print_ptr(ndr, "fields", r->fields);
13080         ndr->depth++;
13081         if (r->fields) {
13082                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
13083                 ndr->depth++;
13084                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
13085                         char *idx_1=NULL;
13086                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
13087                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
13088                                 free(idx_1);
13089                         }
13090                 }
13091                 ndr->depth--;
13092         }
13093         ndr->depth--;
13094         ndr->depth--;
13095 }
13096
13097 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
13098 {
13099         uint32_t cntr_types_1;
13100         if (ndr_flags & NDR_SCALARS) {
13101                 NDR_CHECK(ndr_push_align(ndr, 4));
13102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13105                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
13106         }
13107         if (ndr_flags & NDR_BUFFERS) {
13108                 if (r->types) {
13109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13110                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13111                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13112                         }
13113                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13114                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13115                         }
13116                 }
13117         }
13118         return NDR_ERR_SUCCESS;
13119 }
13120
13121 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
13122 {
13123         uint32_t _ptr_types;
13124         uint32_t cntr_types_1;
13125         TALLOC_CTX *_mem_save_types_0;
13126         TALLOC_CTX *_mem_save_types_1;
13127         if (ndr_flags & NDR_SCALARS) {
13128                 NDR_CHECK(ndr_pull_align(ndr, 4));
13129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
13133                 if (_ptr_types) {
13134                         NDR_PULL_ALLOC(ndr, r->types);
13135                 } else {
13136                         r->types = NULL;
13137                 }
13138         }
13139         if (ndr_flags & NDR_BUFFERS) {
13140                 if (r->types) {
13141                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
13142                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
13144                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
13145                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
13146                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13147                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13148                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13149                         }
13150                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13151                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13152                         }
13153                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
13154                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
13155                 }
13156                 if (r->types) {
13157                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
13158                 }
13159         }
13160         return NDR_ERR_SUCCESS;
13161 }
13162
13163 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
13164 {
13165         uint32_t cntr_types_1;
13166         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
13167         ndr->depth++;
13168         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13169         ndr_print_uint32(ndr, "flags", r->flags);
13170         ndr_print_uint32(ndr, "count", r->count);
13171         ndr_print_ptr(ndr, "types", r->types);
13172         ndr->depth++;
13173         if (r->types) {
13174                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
13175                 ndr->depth++;
13176                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
13177                         char *idx_1=NULL;
13178                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
13179                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
13180                                 free(idx_1);
13181                         }
13182                 }
13183                 ndr->depth--;
13184         }
13185         ndr->depth--;
13186         ndr->depth--;
13187 }
13188
13189 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
13190 {
13191         if (ndr_flags & NDR_SCALARS) {
13192                 NDR_CHECK(ndr_push_align(ndr, 4));
13193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
13195         }
13196         if (ndr_flags & NDR_BUFFERS) {
13197                 if (r->string) {
13198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
13199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
13200                 }
13201         }
13202         return NDR_ERR_SUCCESS;
13203 }
13204
13205 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
13206 {
13207         uint32_t _ptr_string;
13208         TALLOC_CTX *_mem_save_string_0;
13209         if (ndr_flags & NDR_SCALARS) {
13210                 NDR_CHECK(ndr_pull_align(ndr, 4));
13211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
13213                 if (_ptr_string) {
13214                         NDR_PULL_ALLOC(ndr, r->string);
13215                 } else {
13216                         r->string = NULL;
13217                 }
13218         }
13219         if (ndr_flags & NDR_BUFFERS) {
13220                 if (r->string) {
13221                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
13222                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
13223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
13224                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
13225                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
13226                 }
13227                 if (r->string) {
13228                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
13229                 }
13230         }
13231         return NDR_ERR_SUCCESS;
13232 }
13233
13234 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
13235 {
13236         ndr_print_struct(ndr, name, "spoolss_NotifyString");
13237         ndr->depth++;
13238         ndr_print_uint32(ndr, "size", r->size);
13239         ndr_print_ptr(ndr, "string", r->string);
13240         ndr->depth++;
13241         if (r->string) {
13242                 ndr_print_string(ndr, "string", r->string);
13243         }
13244         ndr->depth--;
13245         ndr->depth--;
13246 }
13247
13248 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
13249 {
13250         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13251         return NDR_ERR_SUCCESS;
13252 }
13253
13254 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
13255 {
13256         uint32_t v;
13257         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13258         *r = v;
13259         return NDR_ERR_SUCCESS;
13260 }
13261
13262 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
13263 {
13264         const char *val = NULL;
13265
13266         switch (r) {
13267                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
13268                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
13269                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
13270                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
13271                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
13272         }
13273         ndr_print_enum(ndr, name, "ENUM", val, r);
13274 }
13275
13276 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
13277 {
13278         if (ndr_flags & NDR_SCALARS) {
13279                 int level = ndr_push_get_switch_value(ndr, r);
13280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13281                 switch (level) {
13282                         case 1: {
13283                                 uint32_t cntr_integer_0;
13284                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13285                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
13286                                 }
13287                         break; }
13288
13289                         case 2: {
13290                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13291                         break; }
13292
13293                         case 3: {
13294                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
13295                         break; }
13296
13297                         case 4: {
13298                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13299                         break; }
13300
13301                         case 5: {
13302                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13303                         break; }
13304
13305                         default:
13306                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13307                 }
13308         }
13309         if (ndr_flags & NDR_BUFFERS) {
13310                 int level = ndr_push_get_switch_value(ndr, r);
13311                 switch (level) {
13312                         case 1:
13313                         break;
13314
13315                         case 2:
13316                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13317                         break;
13318
13319                         case 3:
13320                                 if (r->devmode) {
13321                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
13322                                 }
13323                         break;
13324
13325                         case 4:
13326                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13327                         break;
13328
13329                         case 5:
13330                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13331                         break;
13332
13333                         default:
13334                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13335                 }
13336         }
13337         return NDR_ERR_SUCCESS;
13338 }
13339
13340 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
13341 {
13342         int level;
13343         uint32_t _level;
13344         TALLOC_CTX *_mem_save_devmode_0;
13345         level = ndr_pull_get_switch_value(ndr, r);
13346         if (ndr_flags & NDR_SCALARS) {
13347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13348                 if (_level != level) {
13349                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13350                 }
13351                 switch (level) {
13352                         case 1: {
13353                                 uint32_t cntr_integer_0;
13354                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13355                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
13356                                 }
13357                         break; }
13358
13359                         case 2: {
13360                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13361                         break; }
13362
13363                         case 3: {
13364                                 uint32_t _ptr_devmode;
13365                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
13366                                 if (_ptr_devmode) {
13367                                         NDR_PULL_ALLOC(ndr, r->devmode);
13368                                 } else {
13369                                         r->devmode = NULL;
13370                                 }
13371                         break; }
13372
13373                         case 4: {
13374                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13375                         break; }
13376
13377                         case 5: {
13378                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13379                         break; }
13380
13381                         default:
13382                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13383                 }
13384         }
13385         if (ndr_flags & NDR_BUFFERS) {
13386                 switch (level) {
13387                         case 1:
13388                         break;
13389
13390                         case 2:
13391                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13392                         break;
13393
13394                         case 3:
13395                                 if (r->devmode) {
13396                                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
13397                                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
13398                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
13399                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
13400                                 }
13401                         break;
13402
13403                         case 4:
13404                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13405                         break;
13406
13407                         case 5:
13408                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13409                         break;
13410
13411                         default:
13412                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13413                 }
13414         }
13415         return NDR_ERR_SUCCESS;
13416 }
13417
13418 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
13419 {
13420         int level;
13421         uint32_t cntr_integer_0;
13422         level = ndr_print_get_switch_value(ndr, r);
13423         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
13424         switch (level) {
13425                 case 1:
13426                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
13427                         ndr->depth++;
13428                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
13429                                 char *idx_0=NULL;
13430                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
13431                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
13432                                         free(idx_0);
13433                                 }
13434                         }
13435                         ndr->depth--;
13436                 break;
13437
13438                 case 2:
13439                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
13440                 break;
13441
13442                 case 3:
13443                         ndr_print_ptr(ndr, "devmode", r->devmode);
13444                         ndr->depth++;
13445                         if (r->devmode) {
13446                                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
13447                         }
13448                         ndr->depth--;
13449                 break;
13450
13451                 case 4:
13452                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
13453                 break;
13454
13455                 case 5:
13456                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
13457                 break;
13458
13459                 default:
13460                         ndr_print_bad_level(ndr, name, level);
13461         }
13462 }
13463
13464 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
13465 {
13466         if (ndr_flags & NDR_SCALARS) {
13467                 NDR_CHECK(ndr_push_align(ndr, 4));
13468                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13469                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
13470                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
13471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
13472                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
13473                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13474         }
13475         if (ndr_flags & NDR_BUFFERS) {
13476                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13477         }
13478         return NDR_ERR_SUCCESS;
13479 }
13480
13481 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
13482 {
13483         if (ndr_flags & NDR_SCALARS) {
13484                 NDR_CHECK(ndr_pull_align(ndr, 4));
13485                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13486                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
13487                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
13488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
13489                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
13490                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13491         }
13492         if (ndr_flags & NDR_BUFFERS) {
13493                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13494         }
13495         return NDR_ERR_SUCCESS;
13496 }
13497
13498 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
13499 {
13500         ndr_print_struct(ndr, name, "spoolss_Notify");
13501         ndr->depth++;
13502         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13503         ndr_print_spoolss_Field(ndr, "field", r->field);
13504         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
13505         ndr_print_uint32(ndr, "job_id", r->job_id);
13506         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
13507         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
13508         ndr->depth--;
13509 }
13510
13511 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
13512 {
13513         uint32_t cntr_notifies_0;
13514         if (ndr_flags & NDR_SCALARS) {
13515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13516                 NDR_CHECK(ndr_push_align(ndr, 4));
13517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13520                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13521                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13522                 }
13523         }
13524         if (ndr_flags & NDR_BUFFERS) {
13525                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13526                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13527                 }
13528         }
13529         return NDR_ERR_SUCCESS;
13530 }
13531
13532 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
13533 {
13534         uint32_t cntr_notifies_0;
13535         TALLOC_CTX *_mem_save_notifies_0;
13536         if (ndr_flags & NDR_SCALARS) {
13537                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
13538                 NDR_CHECK(ndr_pull_align(ndr, 4));
13539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13542                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
13543                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13544                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13545                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13546                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13547                 }
13548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13549                 if (r->notifies) {
13550                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
13551                 }
13552         }
13553         if (ndr_flags & NDR_BUFFERS) {
13554                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13555                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13556                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13557                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13558                 }
13559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13560         }
13561         return NDR_ERR_SUCCESS;
13562 }
13563
13564 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
13565 {
13566         uint32_t cntr_notifies_0;
13567         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
13568         ndr->depth++;
13569         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13570         ndr_print_uint32(ndr, "flags", r->flags);
13571         ndr_print_uint32(ndr, "count", r->count);
13572         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
13573         ndr->depth++;
13574         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
13575                 char *idx_0=NULL;
13576                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
13577                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
13578                         free(idx_0);
13579                 }
13580         }
13581         ndr->depth--;
13582         ndr->depth--;
13583 }
13584
13585 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
13586 {
13587         if (ndr_flags & NDR_SCALARS) {
13588                 int level = ndr_push_get_switch_value(ndr, r);
13589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13590                 switch (level) {
13591                         case 0: {
13592                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
13593                         break; }
13594
13595                         default:
13596                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13597                 }
13598         }
13599         if (ndr_flags & NDR_BUFFERS) {
13600                 int level = ndr_push_get_switch_value(ndr, r);
13601                 switch (level) {
13602                         case 0:
13603                                 if (r->info0) {
13604                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13605                                 }
13606                         break;
13607
13608                         default:
13609                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13610                 }
13611         }
13612         return NDR_ERR_SUCCESS;
13613 }
13614
13615 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
13616 {
13617         int level;
13618         uint32_t _level;
13619         TALLOC_CTX *_mem_save_info0_0;
13620         level = ndr_pull_get_switch_value(ndr, r);
13621         if (ndr_flags & NDR_SCALARS) {
13622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13623                 if (_level != level) {
13624                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13625                 }
13626                 switch (level) {
13627                         case 0: {
13628                                 uint32_t _ptr_info0;
13629                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
13630                                 if (_ptr_info0) {
13631                                         NDR_PULL_ALLOC(ndr, r->info0);
13632                                 } else {
13633                                         r->info0 = NULL;
13634                                 }
13635                         break; }
13636
13637                         default:
13638                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13639                 }
13640         }
13641         if (ndr_flags & NDR_BUFFERS) {
13642                 switch (level) {
13643                         case 0:
13644                                 if (r->info0) {
13645                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
13646                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
13647                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13648                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
13649                                 }
13650                         break;
13651
13652                         default:
13653                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13654                 }
13655         }
13656         return NDR_ERR_SUCCESS;
13657 }
13658
13659 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
13660 {
13661         int level;
13662         level = ndr_print_get_switch_value(ndr, r);
13663         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
13664         switch (level) {
13665                 case 0:
13666                         ndr_print_ptr(ndr, "info0", r->info0);
13667                         ndr->depth++;
13668                         if (r->info0) {
13669                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
13670                         }
13671                         ndr->depth--;
13672                 break;
13673
13674                 default:
13675                         ndr_print_bad_level(ndr, name, level);
13676         }
13677 }
13678
13679 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13680 {
13681         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13682         return NDR_ERR_SUCCESS;
13683 }
13684
13685 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13686 {
13687         uint32_t v;
13688         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13689         *r = v;
13690         return NDR_ERR_SUCCESS;
13691 }
13692
13693 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13694 {
13695         ndr_print_uint32(ndr, name, r);
13696         ndr->depth++;
13697         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
13698         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
13699         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
13700         ndr->depth--;
13701 }
13702
13703 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
13704 {
13705         if (ndr_flags & NDR_SCALARS) {
13706                 NDR_CHECK(ndr_push_align(ndr, 4));
13707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
13709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
13710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13711                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
13712                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
13713                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
13714         }
13715         if (ndr_flags & NDR_BUFFERS) {
13716                 if (r->client) {
13717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13720                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13721                 }
13722                 if (r->user) {
13723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13727                 }
13728         }
13729         return NDR_ERR_SUCCESS;
13730 }
13731
13732 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
13733 {
13734         uint32_t _ptr_client;
13735         TALLOC_CTX *_mem_save_client_0;
13736         uint32_t _ptr_user;
13737         TALLOC_CTX *_mem_save_user_0;
13738         if (ndr_flags & NDR_SCALARS) {
13739                 NDR_CHECK(ndr_pull_align(ndr, 4));
13740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
13742                 if (_ptr_client) {
13743                         NDR_PULL_ALLOC(ndr, r->client);
13744                 } else {
13745                         r->client = NULL;
13746                 }
13747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13748                 if (_ptr_user) {
13749                         NDR_PULL_ALLOC(ndr, r->user);
13750                 } else {
13751                         r->user = NULL;
13752                 }
13753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13754                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
13755                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
13756                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
13757         }
13758         if (ndr_flags & NDR_BUFFERS) {
13759                 if (r->client) {
13760                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
13761                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
13762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
13763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
13764                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
13765                                 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));
13766                         }
13767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
13768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
13769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
13770                 }
13771                 if (r->user) {
13772                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13773                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
13774                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
13775                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
13776                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
13777                                 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));
13778                         }
13779                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
13780                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
13781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13782                 }
13783         }
13784         return NDR_ERR_SUCCESS;
13785 }
13786
13787 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
13788 {
13789         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
13790         ndr->depth++;
13791         ndr_print_uint32(ndr, "size", r->size);
13792         ndr_print_ptr(ndr, "client", r->client);
13793         ndr->depth++;
13794         if (r->client) {
13795                 ndr_print_string(ndr, "client", r->client);
13796         }
13797         ndr->depth--;
13798         ndr_print_ptr(ndr, "user", r->user);
13799         ndr->depth++;
13800         if (r->user) {
13801                 ndr_print_string(ndr, "user", r->user);
13802         }
13803         ndr->depth--;
13804         ndr_print_uint32(ndr, "build", r->build);
13805         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
13806         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
13807         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
13808         ndr->depth--;
13809 }
13810
13811 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
13812 {
13813         if (ndr_flags & NDR_SCALARS) {
13814                 NDR_CHECK(ndr_push_align(ndr, 4));
13815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
13816         }
13817         if (ndr_flags & NDR_BUFFERS) {
13818         }
13819         return NDR_ERR_SUCCESS;
13820 }
13821
13822 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
13823 {
13824         if (ndr_flags & NDR_SCALARS) {
13825                 NDR_CHECK(ndr_pull_align(ndr, 4));
13826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
13827         }
13828         if (ndr_flags & NDR_BUFFERS) {
13829         }
13830         return NDR_ERR_SUCCESS;
13831 }
13832
13833 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
13834 {
13835         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
13836         ndr->depth++;
13837         ndr_print_uint32(ndr, "not_used", r->not_used);
13838         ndr->depth--;
13839 }
13840
13841 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
13842 {
13843         if (ndr_flags & NDR_SCALARS) {
13844                 NDR_CHECK(ndr_push_align(ndr, 4));
13845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
13848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
13849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
13850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13851                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
13852                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
13853                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
13854                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
13855         }
13856         if (ndr_flags & NDR_BUFFERS) {
13857                 if (r->client) {
13858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13862                 }
13863                 if (r->user) {
13864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13868                 }
13869         }
13870         return NDR_ERR_SUCCESS;
13871 }
13872
13873 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
13874 {
13875         uint32_t _ptr_client;
13876         TALLOC_CTX *_mem_save_client_0;
13877         uint32_t _ptr_user;
13878         TALLOC_CTX *_mem_save_user_0;
13879         if (ndr_flags & NDR_SCALARS) {
13880                 NDR_CHECK(ndr_pull_align(ndr, 4));
13881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
13884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
13885                 if (_ptr_client) {
13886                         NDR_PULL_ALLOC(ndr, r->client);
13887                 } else {
13888                         r->client = NULL;
13889                 }
13890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13891                 if (_ptr_user) {
13892                         NDR_PULL_ALLOC(ndr, r->user);
13893                 } else {
13894                         r->user = NULL;
13895                 }
13896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13897                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
13898                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
13899                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
13900                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
13901         }
13902         if (ndr_flags & NDR_BUFFERS) {
13903                 if (r->client) {
13904                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
13905                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
13906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
13907                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
13908                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
13909                                 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));
13910                         }
13911                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
13912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
13913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
13914                 }
13915                 if (r->user) {
13916                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13917                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
13918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
13919                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
13920                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
13921                                 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));
13922                         }
13923                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
13924                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
13925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13926                 }
13927         }
13928         return NDR_ERR_SUCCESS;
13929 }
13930
13931 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
13932 {
13933         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
13934         ndr->depth++;
13935         ndr_print_uint32(ndr, "size", r->size);
13936         ndr_print_uint32(ndr, "flags", r->flags);
13937         ndr_print_uint32(ndr, "size2", r->size2);
13938         ndr_print_ptr(ndr, "client", r->client);
13939         ndr->depth++;
13940         if (r->client) {
13941                 ndr_print_string(ndr, "client", r->client);
13942         }
13943         ndr->depth--;
13944         ndr_print_ptr(ndr, "user", r->user);
13945         ndr->depth++;
13946         if (r->user) {
13947                 ndr_print_string(ndr, "user", r->user);
13948         }
13949         ndr->depth--;
13950         ndr_print_uint32(ndr, "build", r->build);
13951         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
13952         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
13953         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
13954         ndr_print_udlong(ndr, "reserved", r->reserved);
13955         ndr->depth--;
13956 }
13957
13958 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
13959 {
13960         if (ndr_flags & NDR_SCALARS) {
13961                 int level = ndr_push_get_switch_value(ndr, r);
13962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13963                 switch (level) {
13964                         case 1: {
13965                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
13966                         break; }
13967
13968                         case 2: {
13969                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
13970                         break; }
13971
13972                         case 3: {
13973                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
13974                         break; }
13975
13976                         default:
13977                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13978                 }
13979         }
13980         if (ndr_flags & NDR_BUFFERS) {
13981                 int level = ndr_push_get_switch_value(ndr, r);
13982                 switch (level) {
13983                         case 1:
13984                                 if (r->level1) {
13985                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
13986                                 }
13987                         break;
13988
13989                         case 2:
13990                                 if (r->level2) {
13991                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
13992                                 }
13993                         break;
13994
13995                         case 3:
13996                                 if (r->level3) {
13997                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
13998                                 }
13999                         break;
14000
14001                         default:
14002                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14003                 }
14004         }
14005         return NDR_ERR_SUCCESS;
14006 }
14007
14008 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
14009 {
14010         int level;
14011         uint32_t _level;
14012         TALLOC_CTX *_mem_save_level1_0;
14013         TALLOC_CTX *_mem_save_level2_0;
14014         TALLOC_CTX *_mem_save_level3_0;
14015         level = ndr_pull_get_switch_value(ndr, r);
14016         if (ndr_flags & NDR_SCALARS) {
14017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14018                 if (_level != level) {
14019                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14020                 }
14021                 switch (level) {
14022                         case 1: {
14023                                 uint32_t _ptr_level1;
14024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
14025                                 if (_ptr_level1) {
14026                                         NDR_PULL_ALLOC(ndr, r->level1);
14027                                 } else {
14028                                         r->level1 = NULL;
14029                                 }
14030                         break; }
14031
14032                         case 2: {
14033                                 uint32_t _ptr_level2;
14034                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
14035                                 if (_ptr_level2) {
14036                                         NDR_PULL_ALLOC(ndr, r->level2);
14037                                 } else {
14038                                         r->level2 = NULL;
14039                                 }
14040                         break; }
14041
14042                         case 3: {
14043                                 uint32_t _ptr_level3;
14044                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
14045                                 if (_ptr_level3) {
14046                                         NDR_PULL_ALLOC(ndr, r->level3);
14047                                 } else {
14048                                         r->level3 = NULL;
14049                                 }
14050                         break; }
14051
14052                         default:
14053                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14054                 }
14055         }
14056         if (ndr_flags & NDR_BUFFERS) {
14057                 switch (level) {
14058                         case 1:
14059                                 if (r->level1) {
14060                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14061                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
14062                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14063                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
14064                                 }
14065                         break;
14066
14067                         case 2:
14068                                 if (r->level2) {
14069                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
14070                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
14071                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14072                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
14073                                 }
14074                         break;
14075
14076                         case 3:
14077                                 if (r->level3) {
14078                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
14079                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
14080                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14081                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
14082                                 }
14083                         break;
14084
14085                         default:
14086                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14087                 }
14088         }
14089         return NDR_ERR_SUCCESS;
14090 }
14091
14092 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
14093 {
14094         int level;
14095         level = ndr_print_get_switch_value(ndr, r);
14096         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
14097         switch (level) {
14098                 case 1:
14099                         ndr_print_ptr(ndr, "level1", r->level1);
14100                         ndr->depth++;
14101                         if (r->level1) {
14102                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
14103                         }
14104                         ndr->depth--;
14105                 break;
14106
14107                 case 2:
14108                         ndr_print_ptr(ndr, "level2", r->level2);
14109                         ndr->depth++;
14110                         if (r->level2) {
14111                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
14112                         }
14113                         ndr->depth--;
14114                 break;
14115
14116                 case 3:
14117                         ndr_print_ptr(ndr, "level3", r->level3);
14118                         ndr->depth++;
14119                         if (r->level3) {
14120                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
14121                         }
14122                         ndr->depth--;
14123                 break;
14124
14125                 default:
14126                         ndr_print_bad_level(ndr, name, level);
14127         }
14128 }
14129
14130 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
14131 {
14132         if (ndr_flags & NDR_SCALARS) {
14133                 NDR_CHECK(ndr_push_align(ndr, 4));
14134                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
14135                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
14136                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14137         }
14138         if (ndr_flags & NDR_BUFFERS) {
14139                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14140         }
14141         return NDR_ERR_SUCCESS;
14142 }
14143
14144 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
14145 {
14146         if (ndr_flags & NDR_SCALARS) {
14147                 NDR_CHECK(ndr_pull_align(ndr, 4));
14148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
14149                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
14150                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14151         }
14152         if (ndr_flags & NDR_BUFFERS) {
14153                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14154         }
14155         return NDR_ERR_SUCCESS;
14156 }
14157
14158 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
14159 {
14160         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
14161         ndr->depth++;
14162         ndr_print_uint32(ndr, "level", r->level);
14163         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
14164         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
14165         ndr->depth--;
14166 }
14167
14168 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14169 {
14170         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14171         return NDR_ERR_SUCCESS;
14172 }
14173
14174 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14175 {
14176         uint32_t v;
14177         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14178         *r = v;
14179         return NDR_ERR_SUCCESS;
14180 }
14181
14182 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14183 {
14184         ndr_print_uint32(ndr, name, r);
14185         ndr->depth++;
14186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
14187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
14188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
14189         ndr->depth--;
14190 }
14191
14192 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
14193 {
14194         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14195         return NDR_ERR_SUCCESS;
14196 }
14197
14198 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
14199 {
14200         uint32_t v;
14201         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14202         *r = v;
14203         return NDR_ERR_SUCCESS;
14204 }
14205
14206 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
14207 {
14208         const char *val = NULL;
14209
14210         switch (r) {
14211                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
14212                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
14213         }
14214         ndr_print_enum(ndr, name, "ENUM", val, r);
14215 }
14216
14217 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
14218 {
14219         if (ndr_flags & NDR_SCALARS) {
14220                 NDR_CHECK(ndr_push_align(ndr, 4));
14221                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
14223                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14226                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14227                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14229                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14230                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14231                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14232                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14236         }
14237         if (ndr_flags & NDR_BUFFERS) {
14238         }
14239         return NDR_ERR_SUCCESS;
14240 }
14241
14242 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
14243 {
14244         if (ndr_flags & NDR_SCALARS) {
14245                 NDR_CHECK(ndr_pull_align(ndr, 4));
14246                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14248                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14251                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14252                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14254                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14255                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14256                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14257                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14261         }
14262         if (ndr_flags & NDR_BUFFERS) {
14263         }
14264         return NDR_ERR_SUCCESS;
14265 }
14266
14267 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
14268 {
14269         ndr_print_struct(ndr, name, "spoolss_PortData1");
14270         ndr->depth++;
14271         ndr_print_string(ndr, "portname", r->portname);
14272         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
14273         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14274         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14275         ndr_print_uint32(ndr, "reserved", r->reserved);
14276         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14277         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14278         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14279         ndr_print_string(ndr, "queue", r->queue);
14280         ndr_print_string(ndr, "ip_address", r->ip_address);
14281         ndr_print_string(ndr, "hardware_address", r->hardware_address);
14282         ndr_print_string(ndr, "device_type", r->device_type);
14283         ndr_print_uint32(ndr, "port_number", r->port_number);
14284         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14285         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14286         ndr->depth--;
14287 }
14288
14289 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
14290 {
14291         if (ndr_flags & NDR_SCALARS) {
14292                 NDR_CHECK(ndr_push_align(ndr, 4));
14293                 {
14294                         uint32_t _flags_save_string = ndr->flags;
14295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14296                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
14297                         ndr->flags = _flags_save_string;
14298                 }
14299         }
14300         if (ndr_flags & NDR_BUFFERS) {
14301         }
14302         return NDR_ERR_SUCCESS;
14303 }
14304
14305 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
14306 {
14307         if (ndr_flags & NDR_SCALARS) {
14308                 NDR_CHECK(ndr_pull_align(ndr, 4));
14309                 {
14310                         uint32_t _flags_save_string = ndr->flags;
14311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14312                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
14313                         ndr->flags = _flags_save_string;
14314                 }
14315         }
14316         if (ndr_flags & NDR_BUFFERS) {
14317         }
14318         return NDR_ERR_SUCCESS;
14319 }
14320
14321 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
14322 {
14323         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
14324         ndr->depth++;
14325         ndr_print_string(ndr, "dll_name", r->dll_name);
14326         ndr->depth--;
14327 }
14328
14329 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14330 {
14331         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14332         return NDR_ERR_SUCCESS;
14333 }
14334
14335 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14336 {
14337         uint32_t v;
14338         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14339         *r = v;
14340         return NDR_ERR_SUCCESS;
14341 }
14342
14343 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14344 {
14345         ndr_print_uint32(ndr, name, r);
14346         ndr->depth++;
14347         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
14348         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
14349         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
14350         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
14351         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
14352         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
14353         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
14354         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
14355         ndr->depth--;
14356 }
14357
14358 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
14359 {
14360         if (flags & NDR_IN) {
14361                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
14362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14363                 if (r->in.server) {
14364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14367                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14368                 }
14369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14371                 if (r->in.buffer) {
14372                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14373                 }
14374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14375         }
14376         if (flags & NDR_OUT) {
14377                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14378                 if (r->out.info) {
14379                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
14380                 }
14381                 if (r->out.needed == NULL) {
14382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14383                 }
14384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14385                 if (r->out.count == NULL) {
14386                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14387                 }
14388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
14389                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14390         }
14391         return NDR_ERR_SUCCESS;
14392 }
14393
14394 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
14395 {
14396         uint32_t _ptr_server;
14397         uint32_t _ptr_buffer;
14398         uint32_t _ptr_info;
14399         TALLOC_CTX *_mem_save_server_0;
14400         TALLOC_CTX *_mem_save_buffer_0;
14401         TALLOC_CTX *_mem_save_info_0;
14402         TALLOC_CTX *_mem_save_needed_0;
14403         TALLOC_CTX *_mem_save_count_0;
14404         if (flags & NDR_IN) {
14405                 ZERO_STRUCT(r->out);
14406
14407                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
14408                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14409                 if (_ptr_server) {
14410                         NDR_PULL_ALLOC(ndr, r->in.server);
14411                 } else {
14412                         r->in.server = NULL;
14413                 }
14414                 if (r->in.server) {
14415                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14416                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14417                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14418                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14419                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14420                                 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));
14421                         }
14422                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14423                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14425                 }
14426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14428                 if (_ptr_buffer) {
14429                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14430                 } else {
14431                         r->in.buffer = NULL;
14432                 }
14433                 if (r->in.buffer) {
14434                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14435                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14436                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14438                 }
14439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14440                 NDR_PULL_ALLOC(ndr, r->out.needed);
14441                 ZERO_STRUCTP(r->out.needed);
14442                 NDR_PULL_ALLOC(ndr, r->out.count);
14443                 ZERO_STRUCTP(r->out.count);
14444         }
14445         if (flags & NDR_OUT) {
14446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14447                 if (_ptr_info) {
14448                         NDR_PULL_ALLOC(ndr, r->out.info);
14449                 } else {
14450                         r->out.info = NULL;
14451                 }
14452                 if (r->out.info) {
14453                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14454                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14455                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
14456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14457                 }
14458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14459                         NDR_PULL_ALLOC(ndr, r->out.needed);
14460                 }
14461                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14462                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14466                         NDR_PULL_ALLOC(ndr, r->out.count);
14467                 }
14468                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
14469                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
14470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
14471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
14472                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14473         }
14474         return NDR_ERR_SUCCESS;
14475 }
14476
14477 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
14478 {
14479         uint32_t cntr_info_0;
14480         if (flags & NDR_IN) {
14481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
14483         }
14484         if (flags & NDR_OUT) {
14485                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14486                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14487                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14488                 }
14489                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14490                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14491                 }
14492         }
14493         return NDR_ERR_SUCCESS;
14494 }
14495
14496 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
14497 {
14498         uint32_t cntr_info_0;
14499         TALLOC_CTX *_mem_save_info_0;
14500         if (flags & NDR_IN) {
14501                 ZERO_STRUCT(r->out);
14502
14503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
14505         }
14506         if (flags & NDR_OUT) {
14507                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
14508                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14509                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14510                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14511                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14512                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14513                 }
14514                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14515                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14516                 }
14517                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14518         }
14519         return NDR_ERR_SUCCESS;
14520 }
14521
14522 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
14523 {
14524         uint32_t cntr_info_1;
14525         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
14526         ndr->depth++;
14527         if (flags & NDR_SET_VALUES) {
14528                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14529         }
14530         if (flags & NDR_IN) {
14531                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
14532                 ndr->depth++;
14533                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
14534                 ndr_print_ptr(ndr, "server", r->in.server);
14535                 ndr->depth++;
14536                 if (r->in.server) {
14537                         ndr_print_string(ndr, "server", r->in.server);
14538                 }
14539                 ndr->depth--;
14540                 ndr_print_uint32(ndr, "level", r->in.level);
14541                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14542                 ndr->depth++;
14543                 if (r->in.buffer) {
14544                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14545                 }
14546                 ndr->depth--;
14547                 ndr_print_uint32(ndr, "offered", r->in.offered);
14548                 ndr->depth--;
14549         }
14550         if (flags & NDR_OUT) {
14551                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
14552                 ndr->depth++;
14553                 ndr_print_ptr(ndr, "count", r->out.count);
14554                 ndr->depth++;
14555                 ndr_print_uint32(ndr, "count", *r->out.count);
14556                 ndr->depth--;
14557                 ndr_print_ptr(ndr, "info", r->out.info);
14558                 ndr->depth++;
14559                 if (r->out.info) {
14560                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
14561                         ndr->depth++;
14562                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
14563                                 char *idx_1=NULL;
14564                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
14565                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
14566                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
14567                                         free(idx_1);
14568                                 }
14569                         }
14570                         ndr->depth--;
14571                 }
14572                 ndr->depth--;
14573                 ndr_print_ptr(ndr, "needed", r->out.needed);
14574                 ndr->depth++;
14575                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14576                 ndr->depth--;
14577                 ndr_print_WERROR(ndr, "result", r->out.result);
14578                 ndr->depth--;
14579         }
14580         ndr->depth--;
14581 }
14582
14583 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
14584 {
14585         if (flags & NDR_IN) {
14586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
14587                 if (r->in.printername) {
14588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14592                 }
14593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
14594                 if (r->in.datatype) {
14595                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14598                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14599                 }
14600                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
14602         }
14603         if (flags & NDR_OUT) {
14604                 if (r->out.handle == NULL) {
14605                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14606                 }
14607                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14608                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14609         }
14610         return NDR_ERR_SUCCESS;
14611 }
14612
14613 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
14614 {
14615         uint32_t _ptr_printername;
14616         uint32_t _ptr_datatype;
14617         TALLOC_CTX *_mem_save_printername_0;
14618         TALLOC_CTX *_mem_save_datatype_0;
14619         TALLOC_CTX *_mem_save_handle_0;
14620         if (flags & NDR_IN) {
14621                 ZERO_STRUCT(r->out);
14622
14623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
14624                 if (_ptr_printername) {
14625                         NDR_PULL_ALLOC(ndr, r->in.printername);
14626                 } else {
14627                         r->in.printername = NULL;
14628                 }
14629                 if (r->in.printername) {
14630                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
14631                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
14632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
14633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
14634                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
14635                                 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));
14636                         }
14637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
14638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
14639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
14640                 }
14641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14642                 if (_ptr_datatype) {
14643                         NDR_PULL_ALLOC(ndr, r->in.datatype);
14644                 } else {
14645                         r->in.datatype = NULL;
14646                 }
14647                 if (r->in.datatype) {
14648                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14649                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
14650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
14651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
14652                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
14653                                 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));
14654                         }
14655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
14656                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
14657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14658                 }
14659                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
14661                 NDR_PULL_ALLOC(ndr, r->out.handle);
14662                 ZERO_STRUCTP(r->out.handle);
14663         }
14664         if (flags & NDR_OUT) {
14665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14666                         NDR_PULL_ALLOC(ndr, r->out.handle);
14667                 }
14668                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14669                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14670                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14672                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14673         }
14674         return NDR_ERR_SUCCESS;
14675 }
14676
14677 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
14678 {
14679         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
14680         ndr->depth++;
14681         if (flags & NDR_SET_VALUES) {
14682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14683         }
14684         if (flags & NDR_IN) {
14685                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
14686                 ndr->depth++;
14687                 ndr_print_ptr(ndr, "printername", r->in.printername);
14688                 ndr->depth++;
14689                 if (r->in.printername) {
14690                         ndr_print_string(ndr, "printername", r->in.printername);
14691                 }
14692                 ndr->depth--;
14693                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
14694                 ndr->depth++;
14695                 if (r->in.datatype) {
14696                         ndr_print_string(ndr, "datatype", r->in.datatype);
14697                 }
14698                 ndr->depth--;
14699                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
14700                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
14701                 ndr->depth--;
14702         }
14703         if (flags & NDR_OUT) {
14704                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
14705                 ndr->depth++;
14706                 ndr_print_ptr(ndr, "handle", r->out.handle);
14707                 ndr->depth++;
14708                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14709                 ndr->depth--;
14710                 ndr_print_WERROR(ndr, "result", r->out.result);
14711                 ndr->depth--;
14712         }
14713         ndr->depth--;
14714 }
14715
14716 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
14717 {
14718         if (flags & NDR_IN) {
14719                 if (r->in.handle == NULL) {
14720                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14721                 }
14722                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
14724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
14725                 if (r->in.ctr) {
14726                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14727                 }
14728                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
14729         }
14730         if (flags & NDR_OUT) {
14731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14732         }
14733         return NDR_ERR_SUCCESS;
14734 }
14735
14736 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
14737 {
14738         uint32_t _ptr_ctr;
14739         TALLOC_CTX *_mem_save_handle_0;
14740         TALLOC_CTX *_mem_save_ctr_0;
14741         if (flags & NDR_IN) {
14742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14743                         NDR_PULL_ALLOC(ndr, r->in.handle);
14744                 }
14745                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14746                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14747                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
14750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
14751                 if (_ptr_ctr) {
14752                         NDR_PULL_ALLOC(ndr, r->in.ctr);
14753                 } else {
14754                         r->in.ctr = NULL;
14755                 }
14756                 if (r->in.ctr) {
14757                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14758                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
14759                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
14761                 }
14762                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
14763         }
14764         if (flags & NDR_OUT) {
14765                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14766         }
14767         return NDR_ERR_SUCCESS;
14768 }
14769
14770 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
14771 {
14772         ndr_print_struct(ndr, name, "spoolss_SetJob");
14773         ndr->depth++;
14774         if (flags & NDR_SET_VALUES) {
14775                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14776         }
14777         if (flags & NDR_IN) {
14778                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
14779                 ndr->depth++;
14780                 ndr_print_ptr(ndr, "handle", r->in.handle);
14781                 ndr->depth++;
14782                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14783                 ndr->depth--;
14784                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
14785                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
14786                 ndr->depth++;
14787                 if (r->in.ctr) {
14788                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
14789                 }
14790                 ndr->depth--;
14791                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
14792                 ndr->depth--;
14793         }
14794         if (flags & NDR_OUT) {
14795                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
14796                 ndr->depth++;
14797                 ndr_print_WERROR(ndr, "result", r->out.result);
14798                 ndr->depth--;
14799         }
14800         ndr->depth--;
14801 }
14802
14803 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
14804 {
14805         if (flags & NDR_IN) {
14806                 if (r->in.handle == NULL) {
14807                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14808                 }
14809                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
14811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14813                 if (r->in.buffer) {
14814                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14815                 }
14816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14817         }
14818         if (flags & NDR_OUT) {
14819                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14820                 if (r->out.info) {
14821                         {
14822                                 struct ndr_push *_ndr_info;
14823                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
14824                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
14825                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14826                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
14827                         }
14828                 }
14829                 if (r->out.needed == NULL) {
14830                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14831                 }
14832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14834         }
14835         return NDR_ERR_SUCCESS;
14836 }
14837
14838 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
14839 {
14840         uint32_t _ptr_buffer;
14841         uint32_t _ptr_info;
14842         TALLOC_CTX *_mem_save_handle_0;
14843         TALLOC_CTX *_mem_save_buffer_0;
14844         TALLOC_CTX *_mem_save_info_0;
14845         TALLOC_CTX *_mem_save_needed_0;
14846         if (flags & NDR_IN) {
14847                 ZERO_STRUCT(r->out);
14848
14849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14850                         NDR_PULL_ALLOC(ndr, r->in.handle);
14851                 }
14852                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14853                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14854                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
14857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14859                 if (_ptr_buffer) {
14860                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14861                 } else {
14862                         r->in.buffer = NULL;
14863                 }
14864                 if (r->in.buffer) {
14865                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14866                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14867                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14869                 }
14870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14871                 NDR_PULL_ALLOC(ndr, r->out.needed);
14872                 ZERO_STRUCTP(r->out.needed);
14873         }
14874         if (flags & NDR_OUT) {
14875                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14876                 if (_ptr_info) {
14877                         NDR_PULL_ALLOC(ndr, r->out.info);
14878                 } else {
14879                         r->out.info = NULL;
14880                 }
14881                 if (r->out.info) {
14882                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14883                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14884                         {
14885                                 struct ndr_pull *_ndr_info;
14886                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
14887                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
14888                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14889                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
14890                         }
14891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14892                 }
14893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14894                         NDR_PULL_ALLOC(ndr, r->out.needed);
14895                 }
14896                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14897                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14900                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14901         }
14902         return NDR_ERR_SUCCESS;
14903 }
14904
14905 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
14906 {
14907         ndr_print_struct(ndr, name, "spoolss_GetJob");
14908         ndr->depth++;
14909         if (flags & NDR_SET_VALUES) {
14910                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14911         }
14912         if (flags & NDR_IN) {
14913                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
14914                 ndr->depth++;
14915                 ndr_print_ptr(ndr, "handle", r->in.handle);
14916                 ndr->depth++;
14917                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14918                 ndr->depth--;
14919                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
14920                 ndr_print_uint32(ndr, "level", r->in.level);
14921                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14922                 ndr->depth++;
14923                 if (r->in.buffer) {
14924                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14925                 }
14926                 ndr->depth--;
14927                 ndr_print_uint32(ndr, "offered", r->in.offered);
14928                 ndr->depth--;
14929         }
14930         if (flags & NDR_OUT) {
14931                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
14932                 ndr->depth++;
14933                 ndr_print_ptr(ndr, "info", r->out.info);
14934                 ndr->depth++;
14935                 if (r->out.info) {
14936                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
14937                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
14938                 }
14939                 ndr->depth--;
14940                 ndr_print_ptr(ndr, "needed", r->out.needed);
14941                 ndr->depth++;
14942                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14943                 ndr->depth--;
14944                 ndr_print_WERROR(ndr, "result", r->out.result);
14945                 ndr->depth--;
14946         }
14947         ndr->depth--;
14948 }
14949
14950 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
14951 {
14952         if (flags & NDR_IN) {
14953                 if (r->in.handle == NULL) {
14954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14955                 }
14956                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
14958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
14959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14961                 if (r->in.buffer) {
14962                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14963                 }
14964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14965         }
14966         if (flags & NDR_OUT) {
14967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14968                 if (r->out.info) {
14969                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
14970                 }
14971                 if (r->out.needed == NULL) {
14972                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14973                 }
14974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14975                 if (r->out.count == NULL) {
14976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14977                 }
14978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
14979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14980         }
14981         return NDR_ERR_SUCCESS;
14982 }
14983
14984 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
14985 {
14986         uint32_t _ptr_buffer;
14987         uint32_t _ptr_info;
14988         TALLOC_CTX *_mem_save_handle_0;
14989         TALLOC_CTX *_mem_save_buffer_0;
14990         TALLOC_CTX *_mem_save_info_0;
14991         TALLOC_CTX *_mem_save_needed_0;
14992         TALLOC_CTX *_mem_save_count_0;
14993         if (flags & NDR_IN) {
14994                 ZERO_STRUCT(r->out);
14995
14996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14997                         NDR_PULL_ALLOC(ndr, r->in.handle);
14998                 }
14999                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15000                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15001                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
15004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
15005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15007                 if (_ptr_buffer) {
15008                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15009                 } else {
15010                         r->in.buffer = NULL;
15011                 }
15012                 if (r->in.buffer) {
15013                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15014                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15015                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15017                 }
15018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15019                 NDR_PULL_ALLOC(ndr, r->out.needed);
15020                 ZERO_STRUCTP(r->out.needed);
15021                 NDR_PULL_ALLOC(ndr, r->out.count);
15022                 ZERO_STRUCTP(r->out.count);
15023         }
15024         if (flags & NDR_OUT) {
15025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15026                 if (_ptr_info) {
15027                         NDR_PULL_ALLOC(ndr, r->out.info);
15028                 } else {
15029                         r->out.info = NULL;
15030                 }
15031                 if (r->out.info) {
15032                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15033                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15034                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15036                 }
15037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15038                         NDR_PULL_ALLOC(ndr, r->out.needed);
15039                 }
15040                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15041                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15042                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15045                         NDR_PULL_ALLOC(ndr, r->out.count);
15046                 }
15047                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15048                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15050                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15051                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15052         }
15053         return NDR_ERR_SUCCESS;
15054 }
15055
15056 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
15057 {
15058         uint32_t cntr_info_0;
15059         if (flags & NDR_IN) {
15060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15062         }
15063         if (flags & NDR_OUT) {
15064                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15065                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15066                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15067                 }
15068                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15069                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15070                 }
15071         }
15072         return NDR_ERR_SUCCESS;
15073 }
15074
15075 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
15076 {
15077         uint32_t cntr_info_0;
15078         TALLOC_CTX *_mem_save_info_0;
15079         if (flags & NDR_IN) {
15080                 ZERO_STRUCT(r->out);
15081
15082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15084         }
15085         if (flags & NDR_OUT) {
15086                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15087                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15088                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15089                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15090                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15091                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15092                 }
15093                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15094                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15095                 }
15096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15097         }
15098         return NDR_ERR_SUCCESS;
15099 }
15100
15101 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
15102 {
15103         uint32_t cntr_info_1;
15104         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
15105         ndr->depth++;
15106         if (flags & NDR_SET_VALUES) {
15107                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15108         }
15109         if (flags & NDR_IN) {
15110                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
15111                 ndr->depth++;
15112                 ndr_print_ptr(ndr, "handle", r->in.handle);
15113                 ndr->depth++;
15114                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15115                 ndr->depth--;
15116                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
15117                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
15118                 ndr_print_uint32(ndr, "level", r->in.level);
15119                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15120                 ndr->depth++;
15121                 if (r->in.buffer) {
15122                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15123                 }
15124                 ndr->depth--;
15125                 ndr_print_uint32(ndr, "offered", r->in.offered);
15126                 ndr->depth--;
15127         }
15128         if (flags & NDR_OUT) {
15129                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
15130                 ndr->depth++;
15131                 ndr_print_ptr(ndr, "count", r->out.count);
15132                 ndr->depth++;
15133                 ndr_print_uint32(ndr, "count", *r->out.count);
15134                 ndr->depth--;
15135                 ndr_print_ptr(ndr, "info", r->out.info);
15136                 ndr->depth++;
15137                 if (r->out.info) {
15138                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15139                         ndr->depth++;
15140                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15141                                 char *idx_1=NULL;
15142                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15143                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15144                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
15145                                         free(idx_1);
15146                                 }
15147                         }
15148                         ndr->depth--;
15149                 }
15150                 ndr->depth--;
15151                 ndr_print_ptr(ndr, "needed", r->out.needed);
15152                 ndr->depth++;
15153                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15154                 ndr->depth--;
15155                 ndr_print_WERROR(ndr, "result", r->out.result);
15156                 ndr->depth--;
15157         }
15158         ndr->depth--;
15159 }
15160
15161 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
15162 {
15163         if (flags & NDR_IN) {
15164         }
15165         if (flags & NDR_OUT) {
15166                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15167         }
15168         return NDR_ERR_SUCCESS;
15169 }
15170
15171 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
15172 {
15173         if (flags & NDR_IN) {
15174         }
15175         if (flags & NDR_OUT) {
15176                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15177         }
15178         return NDR_ERR_SUCCESS;
15179 }
15180
15181 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
15182 {
15183         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
15184         ndr->depth++;
15185         if (flags & NDR_SET_VALUES) {
15186                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15187         }
15188         if (flags & NDR_IN) {
15189                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
15190                 ndr->depth++;
15191                 ndr->depth--;
15192         }
15193         if (flags & NDR_OUT) {
15194                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
15195                 ndr->depth++;
15196                 ndr_print_WERROR(ndr, "result", r->out.result);
15197                 ndr->depth--;
15198         }
15199         ndr->depth--;
15200 }
15201
15202 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
15203 {
15204         if (flags & NDR_IN) {
15205                 if (r->in.handle == NULL) {
15206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15207                 }
15208                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15209         }
15210         if (flags & NDR_OUT) {
15211                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15212         }
15213         return NDR_ERR_SUCCESS;
15214 }
15215
15216 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
15217 {
15218         TALLOC_CTX *_mem_save_handle_0;
15219         if (flags & NDR_IN) {
15220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15221                         NDR_PULL_ALLOC(ndr, r->in.handle);
15222                 }
15223                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15224                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15225                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15227         }
15228         if (flags & NDR_OUT) {
15229                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15230         }
15231         return NDR_ERR_SUCCESS;
15232 }
15233
15234 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
15235 {
15236         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
15237         ndr->depth++;
15238         if (flags & NDR_SET_VALUES) {
15239                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15240         }
15241         if (flags & NDR_IN) {
15242                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
15243                 ndr->depth++;
15244                 ndr_print_ptr(ndr, "handle", r->in.handle);
15245                 ndr->depth++;
15246                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15247                 ndr->depth--;
15248                 ndr->depth--;
15249         }
15250         if (flags & NDR_OUT) {
15251                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
15252                 ndr->depth++;
15253                 ndr_print_WERROR(ndr, "result", r->out.result);
15254                 ndr->depth--;
15255         }
15256         ndr->depth--;
15257 }
15258
15259 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
15260 {
15261         if (flags & NDR_IN) {
15262                 if (r->in.handle == NULL) {
15263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15264                 }
15265                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15266                 if (r->in.info_ctr == NULL) {
15267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15268                 }
15269                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15270                 if (r->in.devmode_ctr == NULL) {
15271                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15272                 }
15273                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15274                 if (r->in.secdesc_ctr == NULL) {
15275                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15276                 }
15277                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15278                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
15279         }
15280         if (flags & NDR_OUT) {
15281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15282         }
15283         return NDR_ERR_SUCCESS;
15284 }
15285
15286 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
15287 {
15288         TALLOC_CTX *_mem_save_handle_0;
15289         TALLOC_CTX *_mem_save_info_ctr_0;
15290         TALLOC_CTX *_mem_save_devmode_ctr_0;
15291         TALLOC_CTX *_mem_save_secdesc_ctr_0;
15292         if (flags & NDR_IN) {
15293                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15294                         NDR_PULL_ALLOC(ndr, r->in.handle);
15295                 }
15296                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15297                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15298                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15299                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15300                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15301                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15302                 }
15303                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15304                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15305                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15306                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15308                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
15309                 }
15310                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15311                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
15312                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15314                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15315                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
15316                 }
15317                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15318                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
15319                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15320                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15321                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
15322         }
15323         if (flags & NDR_OUT) {
15324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15325         }
15326         return NDR_ERR_SUCCESS;
15327 }
15328
15329 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
15330 {
15331         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
15332         ndr->depth++;
15333         if (flags & NDR_SET_VALUES) {
15334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15335         }
15336         if (flags & NDR_IN) {
15337                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
15338                 ndr->depth++;
15339                 ndr_print_ptr(ndr, "handle", r->in.handle);
15340                 ndr->depth++;
15341                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15342                 ndr->depth--;
15343                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15344                 ndr->depth++;
15345                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15346                 ndr->depth--;
15347                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
15348                 ndr->depth++;
15349                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
15350                 ndr->depth--;
15351                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15352                 ndr->depth++;
15353                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15354                 ndr->depth--;
15355                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
15356                 ndr->depth--;
15357         }
15358         if (flags & NDR_OUT) {
15359                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
15360                 ndr->depth++;
15361                 ndr_print_WERROR(ndr, "result", r->out.result);
15362                 ndr->depth--;
15363         }
15364         ndr->depth--;
15365 }
15366
15367 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
15368 {
15369         if (flags & NDR_IN) {
15370                 if (r->in.handle == NULL) {
15371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15372                 }
15373                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15376                 if (r->in.buffer) {
15377                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15378                 }
15379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15380         }
15381         if (flags & NDR_OUT) {
15382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15383                 if (r->out.info) {
15384                         {
15385                                 struct ndr_push *_ndr_info;
15386                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15387                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15388                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15389                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15390                         }
15391                 }
15392                 if (r->out.needed == NULL) {
15393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15394                 }
15395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15397         }
15398         return NDR_ERR_SUCCESS;
15399 }
15400
15401 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
15402 {
15403         uint32_t _ptr_buffer;
15404         uint32_t _ptr_info;
15405         TALLOC_CTX *_mem_save_handle_0;
15406         TALLOC_CTX *_mem_save_buffer_0;
15407         TALLOC_CTX *_mem_save_info_0;
15408         TALLOC_CTX *_mem_save_needed_0;
15409         if (flags & NDR_IN) {
15410                 ZERO_STRUCT(r->out);
15411
15412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15413                         NDR_PULL_ALLOC(ndr, r->in.handle);
15414                 }
15415                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15416                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15417                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15421                 if (_ptr_buffer) {
15422                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15423                 } else {
15424                         r->in.buffer = NULL;
15425                 }
15426                 if (r->in.buffer) {
15427                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15428                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15429                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15431                 }
15432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15433                 NDR_PULL_ALLOC(ndr, r->out.needed);
15434                 ZERO_STRUCTP(r->out.needed);
15435         }
15436         if (flags & NDR_OUT) {
15437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15438                 if (_ptr_info) {
15439                         NDR_PULL_ALLOC(ndr, r->out.info);
15440                 } else {
15441                         r->out.info = NULL;
15442                 }
15443                 if (r->out.info) {
15444                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15445                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15446                         {
15447                                 struct ndr_pull *_ndr_info;
15448                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15449                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15450                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15451                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15452                         }
15453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15454                 }
15455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15456                         NDR_PULL_ALLOC(ndr, r->out.needed);
15457                 }
15458                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15459                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15462                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15463         }
15464         return NDR_ERR_SUCCESS;
15465 }
15466
15467 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
15468 {
15469         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
15470         ndr->depth++;
15471         if (flags & NDR_SET_VALUES) {
15472                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15473         }
15474         if (flags & NDR_IN) {
15475                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
15476                 ndr->depth++;
15477                 ndr_print_ptr(ndr, "handle", r->in.handle);
15478                 ndr->depth++;
15479                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15480                 ndr->depth--;
15481                 ndr_print_uint32(ndr, "level", r->in.level);
15482                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15483                 ndr->depth++;
15484                 if (r->in.buffer) {
15485                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15486                 }
15487                 ndr->depth--;
15488                 ndr_print_uint32(ndr, "offered", r->in.offered);
15489                 ndr->depth--;
15490         }
15491         if (flags & NDR_OUT) {
15492                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
15493                 ndr->depth++;
15494                 ndr_print_ptr(ndr, "info", r->out.info);
15495                 ndr->depth++;
15496                 if (r->out.info) {
15497                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15498                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
15499                 }
15500                 ndr->depth--;
15501                 ndr_print_ptr(ndr, "needed", r->out.needed);
15502                 ndr->depth++;
15503                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15504                 ndr->depth--;
15505                 ndr_print_WERROR(ndr, "result", r->out.result);
15506                 ndr->depth--;
15507         }
15508         ndr->depth--;
15509 }
15510
15511 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
15512 {
15513         if (flags & NDR_IN) {
15514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
15515                 if (r->in.servername) {
15516                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15517                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15519                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15520                 }
15521                 if (r->in.info_ctr == NULL) {
15522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15523                 }
15524                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15525         }
15526         if (flags & NDR_OUT) {
15527                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15528         }
15529         return NDR_ERR_SUCCESS;
15530 }
15531
15532 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
15533 {
15534         uint32_t _ptr_servername;
15535         TALLOC_CTX *_mem_save_servername_0;
15536         TALLOC_CTX *_mem_save_info_ctr_0;
15537         if (flags & NDR_IN) {
15538                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
15539                 if (_ptr_servername) {
15540                         NDR_PULL_ALLOC(ndr, r->in.servername);
15541                 } else {
15542                         r->in.servername = NULL;
15543                 }
15544                 if (r->in.servername) {
15545                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
15546                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
15547                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
15548                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
15549                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
15550                                 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));
15551                         }
15552                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
15553                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
15554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
15555                 }
15556                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15557                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15558                 }
15559                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15560                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15561                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15562                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15563         }
15564         if (flags & NDR_OUT) {
15565                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15566         }
15567         return NDR_ERR_SUCCESS;
15568 }
15569
15570 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
15571 {
15572         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
15573         ndr->depth++;
15574         if (flags & NDR_SET_VALUES) {
15575                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15576         }
15577         if (flags & NDR_IN) {
15578                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
15579                 ndr->depth++;
15580                 ndr_print_ptr(ndr, "servername", r->in.servername);
15581                 ndr->depth++;
15582                 if (r->in.servername) {
15583                         ndr_print_string(ndr, "servername", r->in.servername);
15584                 }
15585                 ndr->depth--;
15586                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15587                 ndr->depth++;
15588                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15589                 ndr->depth--;
15590                 ndr->depth--;
15591         }
15592         if (flags & NDR_OUT) {
15593                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
15594                 ndr->depth++;
15595                 ndr_print_WERROR(ndr, "result", r->out.result);
15596                 ndr->depth--;
15597         }
15598         ndr->depth--;
15599 }
15600
15601 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
15602 {
15603         if (flags & NDR_IN) {
15604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15605                 if (r->in.server) {
15606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15607                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15609                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15610                 }
15611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
15612                 if (r->in.environment) {
15613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15616                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15617                 }
15618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15620                 if (r->in.buffer) {
15621                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15622                 }
15623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15624         }
15625         if (flags & NDR_OUT) {
15626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15627                 if (r->out.info) {
15628                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15629                 }
15630                 if (r->out.needed == NULL) {
15631                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15632                 }
15633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15634                 if (r->out.count == NULL) {
15635                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15636                 }
15637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15638                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15639         }
15640         return NDR_ERR_SUCCESS;
15641 }
15642
15643 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
15644 {
15645         uint32_t _ptr_server;
15646         uint32_t _ptr_environment;
15647         uint32_t _ptr_buffer;
15648         uint32_t _ptr_info;
15649         TALLOC_CTX *_mem_save_server_0;
15650         TALLOC_CTX *_mem_save_environment_0;
15651         TALLOC_CTX *_mem_save_buffer_0;
15652         TALLOC_CTX *_mem_save_info_0;
15653         TALLOC_CTX *_mem_save_needed_0;
15654         TALLOC_CTX *_mem_save_count_0;
15655         if (flags & NDR_IN) {
15656                 ZERO_STRUCT(r->out);
15657
15658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15659                 if (_ptr_server) {
15660                         NDR_PULL_ALLOC(ndr, r->in.server);
15661                 } else {
15662                         r->in.server = NULL;
15663                 }
15664                 if (r->in.server) {
15665                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15666                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15667                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15668                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15669                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15670                                 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));
15671                         }
15672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15673                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15675                 }
15676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
15677                 if (_ptr_environment) {
15678                         NDR_PULL_ALLOC(ndr, r->in.environment);
15679                 } else {
15680                         r->in.environment = NULL;
15681                 }
15682                 if (r->in.environment) {
15683                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
15684                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
15685                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
15686                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
15687                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
15688                                 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));
15689                         }
15690                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
15691                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
15692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
15693                 }
15694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15696                 if (_ptr_buffer) {
15697                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15698                 } else {
15699                         r->in.buffer = NULL;
15700                 }
15701                 if (r->in.buffer) {
15702                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15703                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15704                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15706                 }
15707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15708                 NDR_PULL_ALLOC(ndr, r->out.needed);
15709                 ZERO_STRUCTP(r->out.needed);
15710                 NDR_PULL_ALLOC(ndr, r->out.count);
15711                 ZERO_STRUCTP(r->out.count);
15712         }
15713         if (flags & NDR_OUT) {
15714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15715                 if (_ptr_info) {
15716                         NDR_PULL_ALLOC(ndr, r->out.info);
15717                 } else {
15718                         r->out.info = NULL;
15719                 }
15720                 if (r->out.info) {
15721                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15722                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15723                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15725                 }
15726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15727                         NDR_PULL_ALLOC(ndr, r->out.needed);
15728                 }
15729                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15730                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15732                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15734                         NDR_PULL_ALLOC(ndr, r->out.count);
15735                 }
15736                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15737                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15740                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15741         }
15742         return NDR_ERR_SUCCESS;
15743 }
15744
15745 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
15746 {
15747         uint32_t cntr_info_0;
15748         if (flags & NDR_IN) {
15749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15751         }
15752         if (flags & NDR_OUT) {
15753                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15754                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15755                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15756                 }
15757                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15758                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15759                 }
15760         }
15761         return NDR_ERR_SUCCESS;
15762 }
15763
15764 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
15765 {
15766         uint32_t cntr_info_0;
15767         TALLOC_CTX *_mem_save_info_0;
15768         if (flags & NDR_IN) {
15769                 ZERO_STRUCT(r->out);
15770
15771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15773         }
15774         if (flags & NDR_OUT) {
15775                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15776                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15777                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15778                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15779                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15780                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15781                 }
15782                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15783                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15784                 }
15785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15786         }
15787         return NDR_ERR_SUCCESS;
15788 }
15789
15790 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
15791 {
15792         uint32_t cntr_info_1;
15793         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
15794         ndr->depth++;
15795         if (flags & NDR_SET_VALUES) {
15796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15797         }
15798         if (flags & NDR_IN) {
15799                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
15800                 ndr->depth++;
15801                 ndr_print_ptr(ndr, "server", r->in.server);
15802                 ndr->depth++;
15803                 if (r->in.server) {
15804                         ndr_print_string(ndr, "server", r->in.server);
15805                 }
15806                 ndr->depth--;
15807                 ndr_print_ptr(ndr, "environment", r->in.environment);
15808                 ndr->depth++;
15809                 if (r->in.environment) {
15810                         ndr_print_string(ndr, "environment", r->in.environment);
15811                 }
15812                 ndr->depth--;
15813                 ndr_print_uint32(ndr, "level", r->in.level);
15814                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15815                 ndr->depth++;
15816                 if (r->in.buffer) {
15817                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15818                 }
15819                 ndr->depth--;
15820                 ndr_print_uint32(ndr, "offered", r->in.offered);
15821                 ndr->depth--;
15822         }
15823         if (flags & NDR_OUT) {
15824                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
15825                 ndr->depth++;
15826                 ndr_print_ptr(ndr, "count", r->out.count);
15827                 ndr->depth++;
15828                 ndr_print_uint32(ndr, "count", *r->out.count);
15829                 ndr->depth--;
15830                 ndr_print_ptr(ndr, "info", r->out.info);
15831                 ndr->depth++;
15832                 if (r->out.info) {
15833                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15834                         ndr->depth++;
15835                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15836                                 char *idx_1=NULL;
15837                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15838                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15839                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
15840                                         free(idx_1);
15841                                 }
15842                         }
15843                         ndr->depth--;
15844                 }
15845                 ndr->depth--;
15846                 ndr_print_ptr(ndr, "needed", r->out.needed);
15847                 ndr->depth++;
15848                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15849                 ndr->depth--;
15850                 ndr_print_WERROR(ndr, "result", r->out.result);
15851                 ndr->depth--;
15852         }
15853         ndr->depth--;
15854 }
15855
15856 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
15857 {
15858         if (flags & NDR_IN) {
15859         }
15860         if (flags & NDR_OUT) {
15861                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15862         }
15863         return NDR_ERR_SUCCESS;
15864 }
15865
15866 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
15867 {
15868         if (flags & NDR_IN) {
15869         }
15870         if (flags & NDR_OUT) {
15871                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15872         }
15873         return NDR_ERR_SUCCESS;
15874 }
15875
15876 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
15877 {
15878         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
15879         ndr->depth++;
15880         if (flags & NDR_SET_VALUES) {
15881                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15882         }
15883         if (flags & NDR_IN) {
15884                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
15885                 ndr->depth++;
15886                 ndr->depth--;
15887         }
15888         if (flags & NDR_OUT) {
15889                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
15890                 ndr->depth++;
15891                 ndr_print_WERROR(ndr, "result", r->out.result);
15892                 ndr->depth--;
15893         }
15894         ndr->depth--;
15895 }
15896
15897 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
15898 {
15899         if (flags & NDR_IN) {
15900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15901                 if (r->in.server) {
15902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15905                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15906                 }
15907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
15908                 if (r->in.environment) {
15909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15913                 }
15914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15916                 if (r->in.buffer) {
15917                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15918                 }
15919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15920         }
15921         if (flags & NDR_OUT) {
15922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15923                 if (r->out.info) {
15924                         {
15925                                 struct ndr_push *_ndr_info;
15926                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15927                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15928                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
15929                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15930                         }
15931                 }
15932                 if (r->out.needed == NULL) {
15933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15934                 }
15935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15937         }
15938         return NDR_ERR_SUCCESS;
15939 }
15940
15941 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
15942 {
15943         uint32_t _ptr_server;
15944         uint32_t _ptr_environment;
15945         uint32_t _ptr_buffer;
15946         uint32_t _ptr_info;
15947         TALLOC_CTX *_mem_save_server_0;
15948         TALLOC_CTX *_mem_save_environment_0;
15949         TALLOC_CTX *_mem_save_buffer_0;
15950         TALLOC_CTX *_mem_save_info_0;
15951         TALLOC_CTX *_mem_save_needed_0;
15952         if (flags & NDR_IN) {
15953                 ZERO_STRUCT(r->out);
15954
15955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15956                 if (_ptr_server) {
15957                         NDR_PULL_ALLOC(ndr, r->in.server);
15958                 } else {
15959                         r->in.server = NULL;
15960                 }
15961                 if (r->in.server) {
15962                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15963                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15966                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15967                                 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));
15968                         }
15969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15972                 }
15973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
15974                 if (_ptr_environment) {
15975                         NDR_PULL_ALLOC(ndr, r->in.environment);
15976                 } else {
15977                         r->in.environment = NULL;
15978                 }
15979                 if (r->in.environment) {
15980                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
15981                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
15982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
15983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
15984                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
15985                                 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));
15986                         }
15987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
15988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
15989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
15990                 }
15991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15993                 if (_ptr_buffer) {
15994                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15995                 } else {
15996                         r->in.buffer = NULL;
15997                 }
15998                 if (r->in.buffer) {
15999                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16000                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16001                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16003                 }
16004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16005                 NDR_PULL_ALLOC(ndr, r->out.needed);
16006                 ZERO_STRUCTP(r->out.needed);
16007         }
16008         if (flags & NDR_OUT) {
16009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16010                 if (_ptr_info) {
16011                         NDR_PULL_ALLOC(ndr, r->out.info);
16012                 } else {
16013                         r->out.info = NULL;
16014                 }
16015                 if (r->out.info) {
16016                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16017                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16018                         {
16019                                 struct ndr_pull *_ndr_info;
16020                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16021                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16022                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16023                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16024                         }
16025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16026                 }
16027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16028                         NDR_PULL_ALLOC(ndr, r->out.needed);
16029                 }
16030                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16031                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16034                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16035         }
16036         return NDR_ERR_SUCCESS;
16037 }
16038
16039 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16040 {
16041         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
16042         ndr->depth++;
16043         if (flags & NDR_SET_VALUES) {
16044                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16045         }
16046         if (flags & NDR_IN) {
16047                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
16048                 ndr->depth++;
16049                 ndr_print_ptr(ndr, "server", r->in.server);
16050                 ndr->depth++;
16051                 if (r->in.server) {
16052                         ndr_print_string(ndr, "server", r->in.server);
16053                 }
16054                 ndr->depth--;
16055                 ndr_print_ptr(ndr, "environment", r->in.environment);
16056                 ndr->depth++;
16057                 if (r->in.environment) {
16058                         ndr_print_string(ndr, "environment", r->in.environment);
16059                 }
16060                 ndr->depth--;
16061                 ndr_print_uint32(ndr, "level", r->in.level);
16062                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16063                 ndr->depth++;
16064                 if (r->in.buffer) {
16065                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16066                 }
16067                 ndr->depth--;
16068                 ndr_print_uint32(ndr, "offered", r->in.offered);
16069                 ndr->depth--;
16070         }
16071         if (flags & NDR_OUT) {
16072                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
16073                 ndr->depth++;
16074                 ndr_print_ptr(ndr, "info", r->out.info);
16075                 ndr->depth++;
16076                 if (r->out.info) {
16077                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16078                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
16079                 }
16080                 ndr->depth--;
16081                 ndr_print_ptr(ndr, "needed", r->out.needed);
16082                 ndr->depth++;
16083                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16084                 ndr->depth--;
16085                 ndr_print_WERROR(ndr, "result", r->out.result);
16086                 ndr->depth--;
16087         }
16088         ndr->depth--;
16089 }
16090
16091 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
16092 {
16093         if (flags & NDR_IN) {
16094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16095                 if (r->in.server) {
16096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16097                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16099                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16100                 }
16101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16104                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16108                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16109         }
16110         if (flags & NDR_OUT) {
16111                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16112         }
16113         return NDR_ERR_SUCCESS;
16114 }
16115
16116 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
16117 {
16118         uint32_t _ptr_server;
16119         TALLOC_CTX *_mem_save_server_0;
16120         if (flags & NDR_IN) {
16121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16122                 if (_ptr_server) {
16123                         NDR_PULL_ALLOC(ndr, r->in.server);
16124                 } else {
16125                         r->in.server = NULL;
16126                 }
16127                 if (r->in.server) {
16128                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16129                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16130                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16131                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16132                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16133                                 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));
16134                         }
16135                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16136                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16138                 }
16139                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16140                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16141                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16142                         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));
16143                 }
16144                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16145                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16146                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16147                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16148                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16149                         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));
16150                 }
16151                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16152                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16153         }
16154         if (flags & NDR_OUT) {
16155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16156         }
16157         return NDR_ERR_SUCCESS;
16158 }
16159
16160 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
16161 {
16162         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
16163         ndr->depth++;
16164         if (flags & NDR_SET_VALUES) {
16165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16166         }
16167         if (flags & NDR_IN) {
16168                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
16169                 ndr->depth++;
16170                 ndr_print_ptr(ndr, "server", r->in.server);
16171                 ndr->depth++;
16172                 if (r->in.server) {
16173                         ndr_print_string(ndr, "server", r->in.server);
16174                 }
16175                 ndr->depth--;
16176                 ndr_print_string(ndr, "architecture", r->in.architecture);
16177                 ndr_print_string(ndr, "driver", r->in.driver);
16178                 ndr->depth--;
16179         }
16180         if (flags & NDR_OUT) {
16181                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
16182                 ndr->depth++;
16183                 ndr_print_WERROR(ndr, "result", r->out.result);
16184                 ndr->depth--;
16185         }
16186         ndr->depth--;
16187 }
16188
16189 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
16190 {
16191         if (flags & NDR_IN) {
16192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16193                 if (r->in.server) {
16194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16198                 }
16199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16202                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16206                 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));
16207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16210                 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));
16211         }
16212         if (flags & NDR_OUT) {
16213                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16214         }
16215         return NDR_ERR_SUCCESS;
16216 }
16217
16218 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
16219 {
16220         uint32_t _ptr_server;
16221         TALLOC_CTX *_mem_save_server_0;
16222         if (flags & NDR_IN) {
16223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16224                 if (_ptr_server) {
16225                         NDR_PULL_ALLOC(ndr, r->in.server);
16226                 } else {
16227                         r->in.server = NULL;
16228                 }
16229                 if (r->in.server) {
16230                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16231                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16234                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16235                                 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));
16236                         }
16237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16240                 }
16241                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16242                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16243                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16244                         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));
16245                 }
16246                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16247                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16248                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
16249                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
16250                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
16251                         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));
16252                 }
16253                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
16254                 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));
16255                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
16256                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
16257                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
16258                         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));
16259                 }
16260                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
16261                 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));
16262         }
16263         if (flags & NDR_OUT) {
16264                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16265         }
16266         return NDR_ERR_SUCCESS;
16267 }
16268
16269 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
16270 {
16271         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
16272         ndr->depth++;
16273         if (flags & NDR_SET_VALUES) {
16274                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16275         }
16276         if (flags & NDR_IN) {
16277                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
16278                 ndr->depth++;
16279                 ndr_print_ptr(ndr, "server", r->in.server);
16280                 ndr->depth++;
16281                 if (r->in.server) {
16282                         ndr_print_string(ndr, "server", r->in.server);
16283                 }
16284                 ndr->depth--;
16285                 ndr_print_string(ndr, "architecture", r->in.architecture);
16286                 ndr_print_string(ndr, "path_name", r->in.path_name);
16287                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
16288                 ndr->depth--;
16289         }
16290         if (flags & NDR_OUT) {
16291                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
16292                 ndr->depth++;
16293                 ndr_print_WERROR(ndr, "result", r->out.result);
16294                 ndr->depth--;
16295         }
16296         ndr->depth--;
16297 }
16298
16299 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
16300 {
16301         if (flags & NDR_IN) {
16302                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16303                 if (r->in.servername) {
16304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16306                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16307                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16308                 }
16309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16310                 if (r->in.environment) {
16311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16315                 }
16316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16318                 if (r->in.buffer) {
16319                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16320                 }
16321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16322         }
16323         if (flags & NDR_OUT) {
16324                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16325                 if (r->out.info) {
16326                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16327                 }
16328                 if (r->out.needed == NULL) {
16329                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16330                 }
16331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16332                 if (r->out.count == NULL) {
16333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16334                 }
16335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16337         }
16338         return NDR_ERR_SUCCESS;
16339 }
16340
16341 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
16342 {
16343         uint32_t _ptr_servername;
16344         uint32_t _ptr_environment;
16345         uint32_t _ptr_buffer;
16346         uint32_t _ptr_info;
16347         TALLOC_CTX *_mem_save_servername_0;
16348         TALLOC_CTX *_mem_save_environment_0;
16349         TALLOC_CTX *_mem_save_buffer_0;
16350         TALLOC_CTX *_mem_save_info_0;
16351         TALLOC_CTX *_mem_save_needed_0;
16352         TALLOC_CTX *_mem_save_count_0;
16353         if (flags & NDR_IN) {
16354                 ZERO_STRUCT(r->out);
16355
16356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16357                 if (_ptr_servername) {
16358                         NDR_PULL_ALLOC(ndr, r->in.servername);
16359                 } else {
16360                         r->in.servername = NULL;
16361                 }
16362                 if (r->in.servername) {
16363                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16364                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16367                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16368                                 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));
16369                         }
16370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16373                 }
16374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16375                 if (_ptr_environment) {
16376                         NDR_PULL_ALLOC(ndr, r->in.environment);
16377                 } else {
16378                         r->in.environment = NULL;
16379                 }
16380                 if (r->in.environment) {
16381                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16383                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16384                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16385                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16386                                 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));
16387                         }
16388                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16389                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16390                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16391                 }
16392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16393                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16394                 if (_ptr_buffer) {
16395                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16396                 } else {
16397                         r->in.buffer = NULL;
16398                 }
16399                 if (r->in.buffer) {
16400                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16401                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16402                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16404                 }
16405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16406                 NDR_PULL_ALLOC(ndr, r->out.needed);
16407                 ZERO_STRUCTP(r->out.needed);
16408                 NDR_PULL_ALLOC(ndr, r->out.count);
16409                 ZERO_STRUCTP(r->out.count);
16410         }
16411         if (flags & NDR_OUT) {
16412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16413                 if (_ptr_info) {
16414                         NDR_PULL_ALLOC(ndr, r->out.info);
16415                 } else {
16416                         r->out.info = NULL;
16417                 }
16418                 if (r->out.info) {
16419                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16420                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16421                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16423                 }
16424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16425                         NDR_PULL_ALLOC(ndr, r->out.needed);
16426                 }
16427                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16428                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16431                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16432                         NDR_PULL_ALLOC(ndr, r->out.count);
16433                 }
16434                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16435                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16438                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16439         }
16440         return NDR_ERR_SUCCESS;
16441 }
16442
16443 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
16444 {
16445         uint32_t cntr_info_0;
16446         if (flags & NDR_IN) {
16447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16449         }
16450         if (flags & NDR_OUT) {
16451                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16452                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16453                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16454                 }
16455                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16456                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16457                 }
16458         }
16459         return NDR_ERR_SUCCESS;
16460 }
16461
16462 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
16463 {
16464         uint32_t cntr_info_0;
16465         TALLOC_CTX *_mem_save_info_0;
16466         if (flags & NDR_IN) {
16467                 ZERO_STRUCT(r->out);
16468
16469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16471         }
16472         if (flags & NDR_OUT) {
16473                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16474                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16475                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16476                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16477                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16478                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16479                 }
16480                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16481                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16482                 }
16483                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16484         }
16485         return NDR_ERR_SUCCESS;
16486 }
16487
16488 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
16489 {
16490         uint32_t cntr_info_1;
16491         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
16492         ndr->depth++;
16493         if (flags & NDR_SET_VALUES) {
16494                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16495         }
16496         if (flags & NDR_IN) {
16497                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
16498                 ndr->depth++;
16499                 ndr_print_ptr(ndr, "servername", r->in.servername);
16500                 ndr->depth++;
16501                 if (r->in.servername) {
16502                         ndr_print_string(ndr, "servername", r->in.servername);
16503                 }
16504                 ndr->depth--;
16505                 ndr_print_ptr(ndr, "environment", r->in.environment);
16506                 ndr->depth++;
16507                 if (r->in.environment) {
16508                         ndr_print_string(ndr, "environment", r->in.environment);
16509                 }
16510                 ndr->depth--;
16511                 ndr_print_uint32(ndr, "level", r->in.level);
16512                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16513                 ndr->depth++;
16514                 if (r->in.buffer) {
16515                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16516                 }
16517                 ndr->depth--;
16518                 ndr_print_uint32(ndr, "offered", r->in.offered);
16519                 ndr->depth--;
16520         }
16521         if (flags & NDR_OUT) {
16522                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
16523                 ndr->depth++;
16524                 ndr_print_ptr(ndr, "count", r->out.count);
16525                 ndr->depth++;
16526                 ndr_print_uint32(ndr, "count", *r->out.count);
16527                 ndr->depth--;
16528                 ndr_print_ptr(ndr, "info", r->out.info);
16529                 ndr->depth++;
16530                 if (r->out.info) {
16531                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16532                         ndr->depth++;
16533                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16534                                 char *idx_1=NULL;
16535                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16536                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16537                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
16538                                         free(idx_1);
16539                                 }
16540                         }
16541                         ndr->depth--;
16542                 }
16543                 ndr->depth--;
16544                 ndr_print_ptr(ndr, "needed", r->out.needed);
16545                 ndr->depth++;
16546                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16547                 ndr->depth--;
16548                 ndr_print_WERROR(ndr, "result", r->out.result);
16549                 ndr->depth--;
16550         }
16551         ndr->depth--;
16552 }
16553
16554 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16555 {
16556         if (flags & NDR_IN) {
16557         }
16558         if (flags & NDR_OUT) {
16559                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16560         }
16561         return NDR_ERR_SUCCESS;
16562 }
16563
16564 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
16565 {
16566         if (flags & NDR_IN) {
16567         }
16568         if (flags & NDR_OUT) {
16569                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16570         }
16571         return NDR_ERR_SUCCESS;
16572 }
16573
16574 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16575 {
16576         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
16577         ndr->depth++;
16578         if (flags & NDR_SET_VALUES) {
16579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16580         }
16581         if (flags & NDR_IN) {
16582                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
16583                 ndr->depth++;
16584                 ndr->depth--;
16585         }
16586         if (flags & NDR_OUT) {
16587                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
16588                 ndr->depth++;
16589                 ndr_print_WERROR(ndr, "result", r->out.result);
16590                 ndr->depth--;
16591         }
16592         ndr->depth--;
16593 }
16594
16595 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
16596 {
16597         if (flags & NDR_IN) {
16598                 if (r->in.handle == NULL) {
16599                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16600                 }
16601                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16603                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
16604                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16605         }
16606         if (flags & NDR_OUT) {
16607                 if (r->out.job_id == NULL) {
16608                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16609                 }
16610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
16611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16612         }
16613         return NDR_ERR_SUCCESS;
16614 }
16615
16616 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
16617 {
16618         TALLOC_CTX *_mem_save_handle_0;
16619         TALLOC_CTX *_mem_save_job_id_0;
16620         if (flags & NDR_IN) {
16621                 ZERO_STRUCT(r->out);
16622
16623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16624                         NDR_PULL_ALLOC(ndr, r->in.handle);
16625                 }
16626                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16627                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16628                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16631                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
16632                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16633                 NDR_PULL_ALLOC(ndr, r->out.job_id);
16634                 ZERO_STRUCTP(r->out.job_id);
16635         }
16636         if (flags & NDR_OUT) {
16637                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16638                         NDR_PULL_ALLOC(ndr, r->out.job_id);
16639                 }
16640                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
16641                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
16642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
16643                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
16644                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16645         }
16646         return NDR_ERR_SUCCESS;
16647 }
16648
16649 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
16650 {
16651         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
16652         ndr->depth++;
16653         if (flags & NDR_SET_VALUES) {
16654                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16655         }
16656         if (flags & NDR_IN) {
16657                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
16658                 ndr->depth++;
16659                 ndr_print_ptr(ndr, "handle", r->in.handle);
16660                 ndr->depth++;
16661                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16662                 ndr->depth--;
16663                 ndr_print_uint32(ndr, "level", r->in.level);
16664                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
16665                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
16666                 ndr->depth--;
16667         }
16668         if (flags & NDR_OUT) {
16669                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
16670                 ndr->depth++;
16671                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
16672                 ndr->depth++;
16673                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
16674                 ndr->depth--;
16675                 ndr_print_WERROR(ndr, "result", r->out.result);
16676                 ndr->depth--;
16677         }
16678         ndr->depth--;
16679 }
16680
16681 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
16682 {
16683         if (flags & NDR_IN) {
16684                 if (r->in.handle == NULL) {
16685                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16686                 }
16687                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16688         }
16689         if (flags & NDR_OUT) {
16690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16691         }
16692         return NDR_ERR_SUCCESS;
16693 }
16694
16695 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
16696 {
16697         TALLOC_CTX *_mem_save_handle_0;
16698         if (flags & NDR_IN) {
16699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16700                         NDR_PULL_ALLOC(ndr, r->in.handle);
16701                 }
16702                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16703                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16704                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16706         }
16707         if (flags & NDR_OUT) {
16708                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16709         }
16710         return NDR_ERR_SUCCESS;
16711 }
16712
16713 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
16714 {
16715         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
16716         ndr->depth++;
16717         if (flags & NDR_SET_VALUES) {
16718                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16719         }
16720         if (flags & NDR_IN) {
16721                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
16722                 ndr->depth++;
16723                 ndr_print_ptr(ndr, "handle", r->in.handle);
16724                 ndr->depth++;
16725                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16726                 ndr->depth--;
16727                 ndr->depth--;
16728         }
16729         if (flags & NDR_OUT) {
16730                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
16731                 ndr->depth++;
16732                 ndr_print_WERROR(ndr, "result", r->out.result);
16733                 ndr->depth--;
16734         }
16735         ndr->depth--;
16736 }
16737
16738 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
16739 {
16740         if (flags & NDR_IN) {
16741                 if (r->in.handle == NULL) {
16742                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16743                 }
16744                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16745                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
16746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
16747         }
16748         if (flags & NDR_OUT) {
16749                 if (r->out.num_written == NULL) {
16750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16751                 }
16752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
16753                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16754         }
16755         return NDR_ERR_SUCCESS;
16756 }
16757
16758 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
16759 {
16760         TALLOC_CTX *_mem_save_handle_0;
16761         TALLOC_CTX *_mem_save_num_written_0;
16762         if (flags & NDR_IN) {
16763                 ZERO_STRUCT(r->out);
16764
16765                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16766                         NDR_PULL_ALLOC(ndr, r->in.handle);
16767                 }
16768                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16769                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16770                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16772                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
16773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
16774                 NDR_PULL_ALLOC(ndr, r->out.num_written);
16775                 ZERO_STRUCTP(r->out.num_written);
16776         }
16777         if (flags & NDR_OUT) {
16778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16779                         NDR_PULL_ALLOC(ndr, r->out.num_written);
16780                 }
16781                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
16782                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
16783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
16784                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
16785                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16786         }
16787         return NDR_ERR_SUCCESS;
16788 }
16789
16790 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
16791 {
16792         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
16793         ndr->depth++;
16794         if (flags & NDR_SET_VALUES) {
16795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16796         }
16797         if (flags & NDR_IN) {
16798                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
16799                 ndr->depth++;
16800                 ndr_print_ptr(ndr, "handle", r->in.handle);
16801                 ndr->depth++;
16802                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16803                 ndr->depth--;
16804                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
16805                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
16806                 ndr->depth--;
16807         }
16808         if (flags & NDR_OUT) {
16809                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
16810                 ndr->depth++;
16811                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
16812                 ndr->depth++;
16813                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
16814                 ndr->depth--;
16815                 ndr_print_WERROR(ndr, "result", r->out.result);
16816                 ndr->depth--;
16817         }
16818         ndr->depth--;
16819 }
16820
16821 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
16822 {
16823         if (flags & NDR_IN) {
16824                 if (r->in.handle == NULL) {
16825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16826                 }
16827                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16828         }
16829         if (flags & NDR_OUT) {
16830                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16831         }
16832         return NDR_ERR_SUCCESS;
16833 }
16834
16835 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
16836 {
16837         TALLOC_CTX *_mem_save_handle_0;
16838         if (flags & NDR_IN) {
16839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16840                         NDR_PULL_ALLOC(ndr, r->in.handle);
16841                 }
16842                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16843                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16844                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16846         }
16847         if (flags & NDR_OUT) {
16848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16849         }
16850         return NDR_ERR_SUCCESS;
16851 }
16852
16853 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
16854 {
16855         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
16856         ndr->depth++;
16857         if (flags & NDR_SET_VALUES) {
16858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16859         }
16860         if (flags & NDR_IN) {
16861                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
16862                 ndr->depth++;
16863                 ndr_print_ptr(ndr, "handle", r->in.handle);
16864                 ndr->depth++;
16865                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16866                 ndr->depth--;
16867                 ndr->depth--;
16868         }
16869         if (flags & NDR_OUT) {
16870                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
16871                 ndr->depth++;
16872                 ndr_print_WERROR(ndr, "result", r->out.result);
16873                 ndr->depth--;
16874         }
16875         ndr->depth--;
16876 }
16877
16878 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
16879 {
16880         if (flags & NDR_IN) {
16881                 if (r->in.handle == NULL) {
16882                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16883                 }
16884                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16885         }
16886         if (flags & NDR_OUT) {
16887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16888         }
16889         return NDR_ERR_SUCCESS;
16890 }
16891
16892 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
16893 {
16894         TALLOC_CTX *_mem_save_handle_0;
16895         if (flags & NDR_IN) {
16896                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16897                         NDR_PULL_ALLOC(ndr, r->in.handle);
16898                 }
16899                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16900                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16901                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16903         }
16904         if (flags & NDR_OUT) {
16905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16906         }
16907         return NDR_ERR_SUCCESS;
16908 }
16909
16910 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
16911 {
16912         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
16913         ndr->depth++;
16914         if (flags & NDR_SET_VALUES) {
16915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16916         }
16917         if (flags & NDR_IN) {
16918                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
16919                 ndr->depth++;
16920                 ndr_print_ptr(ndr, "handle", r->in.handle);
16921                 ndr->depth++;
16922                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16923                 ndr->depth--;
16924                 ndr->depth--;
16925         }
16926         if (flags & NDR_OUT) {
16927                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
16928                 ndr->depth++;
16929                 ndr_print_WERROR(ndr, "result", r->out.result);
16930                 ndr->depth--;
16931         }
16932         ndr->depth--;
16933 }
16934
16935 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
16936 {
16937         if (flags & NDR_IN) {
16938                 if (r->in.handle == NULL) {
16939                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16940                 }
16941                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
16943         }
16944         if (flags & NDR_OUT) {
16945                 if (r->out.data == NULL) {
16946                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16947                 }
16948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
16949                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
16950                 if (r->out._data_size == NULL) {
16951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16952                 }
16953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
16954                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16955         }
16956         return NDR_ERR_SUCCESS;
16957 }
16958
16959 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
16960 {
16961         TALLOC_CTX *_mem_save_handle_0;
16962         TALLOC_CTX *_mem_save__data_size_0;
16963         if (flags & NDR_IN) {
16964                 ZERO_STRUCT(r->out);
16965
16966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16967                         NDR_PULL_ALLOC(ndr, r->in.handle);
16968                 }
16969                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16971                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
16974                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
16975                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
16976                 NDR_PULL_ALLOC(ndr, r->out._data_size);
16977                 ZERO_STRUCTP(r->out._data_size);
16978         }
16979         if (flags & NDR_OUT) {
16980                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
16981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16982                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
16983                 }
16984                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
16985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16986                         NDR_PULL_ALLOC(ndr, r->out._data_size);
16987                 }
16988                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
16989                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
16990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
16991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
16992                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16993                 if (r->out.data) {
16994                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
16995                 }
16996         }
16997         return NDR_ERR_SUCCESS;
16998 }
16999
17000 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
17001 {
17002         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
17003         ndr->depth++;
17004         if (flags & NDR_SET_VALUES) {
17005                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17006         }
17007         if (flags & NDR_IN) {
17008                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
17009                 ndr->depth++;
17010                 ndr_print_ptr(ndr, "handle", r->in.handle);
17011                 ndr->depth++;
17012                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17013                 ndr->depth--;
17014                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
17015                 ndr->depth--;
17016         }
17017         if (flags & NDR_OUT) {
17018                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
17019                 ndr->depth++;
17020                 ndr_print_ptr(ndr, "data", r->out.data);
17021                 ndr->depth++;
17022                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
17023                 ndr->depth--;
17024                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
17025                 ndr->depth++;
17026                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
17027                 ndr->depth--;
17028                 ndr_print_WERROR(ndr, "result", r->out.result);
17029                 ndr->depth--;
17030         }
17031         ndr->depth--;
17032 }
17033
17034 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
17035 {
17036         if (flags & NDR_IN) {
17037                 if (r->in.handle == NULL) {
17038                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17039                 }
17040                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17041         }
17042         if (flags & NDR_OUT) {
17043                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17044         }
17045         return NDR_ERR_SUCCESS;
17046 }
17047
17048 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
17049 {
17050         TALLOC_CTX *_mem_save_handle_0;
17051         if (flags & NDR_IN) {
17052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17053                         NDR_PULL_ALLOC(ndr, r->in.handle);
17054                 }
17055                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17056                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17057                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17059         }
17060         if (flags & NDR_OUT) {
17061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17062         }
17063         return NDR_ERR_SUCCESS;
17064 }
17065
17066 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
17067 {
17068         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
17069         ndr->depth++;
17070         if (flags & NDR_SET_VALUES) {
17071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17072         }
17073         if (flags & NDR_IN) {
17074                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
17075                 ndr->depth++;
17076                 ndr_print_ptr(ndr, "handle", r->in.handle);
17077                 ndr->depth++;
17078                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17079                 ndr->depth--;
17080                 ndr->depth--;
17081         }
17082         if (flags & NDR_OUT) {
17083                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
17084                 ndr->depth++;
17085                 ndr_print_WERROR(ndr, "result", r->out.result);
17086                 ndr->depth--;
17087         }
17088         ndr->depth--;
17089 }
17090
17091 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
17092 {
17093         if (flags & NDR_IN) {
17094                 if (r->in.handle == NULL) {
17095                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17096                 }
17097                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17100                 if (r->in.buffer) {
17101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17102                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
17103                 }
17104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17105         }
17106         if (flags & NDR_OUT) {
17107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
17108                 if (r->out.buffer) {
17109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17110                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
17111                 }
17112                 if (r->out.needed == NULL) {
17113                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17114                 }
17115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17116                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17117         }
17118         return NDR_ERR_SUCCESS;
17119 }
17120
17121 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
17122 {
17123         uint32_t _ptr_buffer;
17124         TALLOC_CTX *_mem_save_handle_0;
17125         TALLOC_CTX *_mem_save_buffer_0;
17126         TALLOC_CTX *_mem_save_needed_0;
17127         if (flags & NDR_IN) {
17128                 ZERO_STRUCT(r->out);
17129
17130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17131                         NDR_PULL_ALLOC(ndr, r->in.handle);
17132                 }
17133                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17134                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17135                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17139                 if (_ptr_buffer) {
17140                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17141                 } else {
17142                         r->in.buffer = NULL;
17143                 }
17144                 if (r->in.buffer) {
17145                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17146                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
17148                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
17149                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
17150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17151                 }
17152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17153                 NDR_PULL_ALLOC(ndr, r->out.needed);
17154                 ZERO_STRUCTP(r->out.needed);
17155                 if (r->in.buffer) {
17156                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
17157                 }
17158         }
17159         if (flags & NDR_OUT) {
17160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17161                 if (_ptr_buffer) {
17162                         NDR_PULL_ALLOC(ndr, r->out.buffer);
17163                 } else {
17164                         r->out.buffer = NULL;
17165                 }
17166                 if (r->out.buffer) {
17167                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17168                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
17169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
17170                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
17171                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
17172                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17173                 }
17174                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17175                         NDR_PULL_ALLOC(ndr, r->out.needed);
17176                 }
17177                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17178                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17181                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17182                 if (r->out.buffer) {
17183                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
17184                 }
17185         }
17186         return NDR_ERR_SUCCESS;
17187 }
17188
17189 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
17190 {
17191         ndr_print_struct(ndr, name, "spoolss_AddJob");
17192         ndr->depth++;
17193         if (flags & NDR_SET_VALUES) {
17194                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17195         }
17196         if (flags & NDR_IN) {
17197                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
17198                 ndr->depth++;
17199                 ndr_print_ptr(ndr, "handle", r->in.handle);
17200                 ndr->depth++;
17201                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17202                 ndr->depth--;
17203                 ndr_print_uint32(ndr, "level", r->in.level);
17204                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17205                 ndr->depth++;
17206                 if (r->in.buffer) {
17207                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
17208                 }
17209                 ndr->depth--;
17210                 ndr_print_uint32(ndr, "offered", r->in.offered);
17211                 ndr->depth--;
17212         }
17213         if (flags & NDR_OUT) {
17214                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
17215                 ndr->depth++;
17216                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
17217                 ndr->depth++;
17218                 if (r->out.buffer) {
17219                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
17220                 }
17221                 ndr->depth--;
17222                 ndr_print_ptr(ndr, "needed", r->out.needed);
17223                 ndr->depth++;
17224                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17225                 ndr->depth--;
17226                 ndr_print_WERROR(ndr, "result", r->out.result);
17227                 ndr->depth--;
17228         }
17229         ndr->depth--;
17230 }
17231
17232 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
17233 {
17234         if (flags & NDR_IN) {
17235                 if (r->in.handle == NULL) {
17236                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17237                 }
17238                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
17240         }
17241         if (flags & NDR_OUT) {
17242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17243         }
17244         return NDR_ERR_SUCCESS;
17245 }
17246
17247 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
17248 {
17249         TALLOC_CTX *_mem_save_handle_0;
17250         if (flags & NDR_IN) {
17251                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17252                         NDR_PULL_ALLOC(ndr, r->in.handle);
17253                 }
17254                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17255                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17256                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17257                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
17259         }
17260         if (flags & NDR_OUT) {
17261                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17262         }
17263         return NDR_ERR_SUCCESS;
17264 }
17265
17266 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
17267 {
17268         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
17269         ndr->depth++;
17270         if (flags & NDR_SET_VALUES) {
17271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17272         }
17273         if (flags & NDR_IN) {
17274                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
17275                 ndr->depth++;
17276                 ndr_print_ptr(ndr, "handle", r->in.handle);
17277                 ndr->depth++;
17278                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17279                 ndr->depth--;
17280                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
17281                 ndr->depth--;
17282         }
17283         if (flags & NDR_OUT) {
17284                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
17285                 ndr->depth++;
17286                 ndr_print_WERROR(ndr, "result", r->out.result);
17287                 ndr->depth--;
17288         }
17289         ndr->depth--;
17290 }
17291
17292 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
17293 {
17294         if (flags & NDR_IN) {
17295                 if (r->in.handle == NULL) {
17296                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17297                 }
17298                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17302                 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));
17303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17304         }
17305         if (flags & NDR_OUT) {
17306                 if (r->out.type == NULL) {
17307                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17308                 }
17309                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
17310                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
17311                 if (r->out.needed == NULL) {
17312                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17313                 }
17314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17315                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17316         }
17317         return NDR_ERR_SUCCESS;
17318 }
17319
17320 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
17321 {
17322         TALLOC_CTX *_mem_save_handle_0;
17323         TALLOC_CTX *_mem_save_type_0;
17324         TALLOC_CTX *_mem_save_needed_0;
17325         if (flags & NDR_IN) {
17326                 ZERO_STRUCT(r->out);
17327
17328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17329                         NDR_PULL_ALLOC(ndr, r->in.handle);
17330                 }
17331                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17333                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17335                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17336                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17337                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17338                         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));
17339                 }
17340                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17341                 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));
17342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17343                 NDR_PULL_ALLOC(ndr, r->out.type);
17344                 ZERO_STRUCTP(r->out.type);
17345                 NDR_PULL_ALLOC(ndr, r->out.needed);
17346                 ZERO_STRUCTP(r->out.needed);
17347         }
17348         if (flags & NDR_OUT) {
17349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17350                         NDR_PULL_ALLOC(ndr, r->out.type);
17351                 }
17352                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
17353                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
17354                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
17355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
17356                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
17357                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17358                         NDR_PULL_ALLOC(ndr, r->out.needed);
17359                 }
17360                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17361                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17364                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17365         }
17366         return NDR_ERR_SUCCESS;
17367 }
17368
17369 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
17370 {
17371         if (flags & NDR_IN) {
17372                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17373         }
17374         if (flags & NDR_OUT) {
17375                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17376                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17377         }
17378         return NDR_ERR_SUCCESS;
17379 }
17380
17381 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
17382 {
17383         if (flags & NDR_IN) {
17384                 ZERO_STRUCT(r->out);
17385
17386                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17387         }
17388         if (flags & NDR_OUT) {
17389                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
17390                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17391         }
17392         return NDR_ERR_SUCCESS;
17393 }
17394
17395 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
17396 {
17397         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
17398         ndr->depth++;
17399         if (flags & NDR_SET_VALUES) {
17400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17401         }
17402         if (flags & NDR_IN) {
17403                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
17404                 ndr->depth++;
17405                 ndr_print_ptr(ndr, "handle", r->in.handle);
17406                 ndr->depth++;
17407                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17408                 ndr->depth--;
17409                 ndr_print_string(ndr, "value_name", r->in.value_name);
17410                 ndr_print_uint32(ndr, "offered", r->in.offered);
17411                 ndr->depth--;
17412         }
17413         if (flags & NDR_OUT) {
17414                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
17415                 ndr->depth++;
17416                 ndr_print_ptr(ndr, "type", r->out.type);
17417                 ndr->depth++;
17418                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
17419                 ndr->depth--;
17420                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
17421                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
17422                 ndr_print_ptr(ndr, "needed", r->out.needed);
17423                 ndr->depth++;
17424                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17425                 ndr->depth--;
17426                 ndr_print_WERROR(ndr, "result", r->out.result);
17427                 ndr->depth--;
17428         }
17429         ndr->depth--;
17430 }
17431
17432 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
17433 {
17434         if (flags & NDR_IN) {
17435                 if (r->in.handle == NULL) {
17436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17437                 }
17438                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17442                 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));
17443                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17444                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
17446         }
17447         if (flags & NDR_OUT) {
17448                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17449         }
17450         return NDR_ERR_SUCCESS;
17451 }
17452
17453 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
17454 {
17455         if (flags & NDR_IN) {
17456                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17457         }
17458         if (flags & NDR_OUT) {
17459                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17460                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17461         }
17462         return NDR_ERR_SUCCESS;
17463 }
17464
17465 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
17466 {
17467         TALLOC_CTX *_mem_save_handle_0;
17468         if (flags & NDR_IN) {
17469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17470                         NDR_PULL_ALLOC(ndr, r->in.handle);
17471                 }
17472                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17473                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17474                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17476                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17477                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17478                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17479                         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));
17480                 }
17481                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17482                 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));
17483                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17484                 {
17485                         struct ndr_pull *_ndr_data;
17486                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
17487                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
17488                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
17489                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
17490                 }
17491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
17492         }
17493         if (flags & NDR_OUT) {
17494                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17495         }
17496         return NDR_ERR_SUCCESS;
17497 }
17498
17499 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
17500 {
17501         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
17502         ndr->depth++;
17503         if (flags & NDR_SET_VALUES) {
17504                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17505         }
17506         if (flags & NDR_IN) {
17507                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
17508                 ndr->depth++;
17509                 ndr_print_ptr(ndr, "handle", r->in.handle);
17510                 ndr->depth++;
17511                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17512                 ndr->depth--;
17513                 ndr_print_string(ndr, "value_name", r->in.value_name);
17514                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
17515                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
17516                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
17517                 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);
17518                 ndr->depth--;
17519         }
17520         if (flags & NDR_OUT) {
17521                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
17522                 ndr->depth++;
17523                 ndr_print_WERROR(ndr, "result", r->out.result);
17524                 ndr->depth--;
17525         }
17526         ndr->depth--;
17527 }
17528
17529 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
17530 {
17531         if (flags & NDR_IN) {
17532         }
17533         if (flags & NDR_OUT) {
17534                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17535         }
17536         return NDR_ERR_SUCCESS;
17537 }
17538
17539 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
17540 {
17541         if (flags & NDR_IN) {
17542         }
17543         if (flags & NDR_OUT) {
17544                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17545         }
17546         return NDR_ERR_SUCCESS;
17547 }
17548
17549 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
17550 {
17551         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
17552         ndr->depth++;
17553         if (flags & NDR_SET_VALUES) {
17554                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17555         }
17556         if (flags & NDR_IN) {
17557                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
17558                 ndr->depth++;
17559                 ndr->depth--;
17560         }
17561         if (flags & NDR_OUT) {
17562                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
17563                 ndr->depth++;
17564                 ndr_print_WERROR(ndr, "result", r->out.result);
17565                 ndr->depth--;
17566         }
17567         ndr->depth--;
17568 }
17569
17570 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
17571 {
17572         if (flags & NDR_IN) {
17573                 if (r->in.handle == NULL) {
17574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17575                 }
17576                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17577         }
17578         if (flags & NDR_OUT) {
17579                 if (r->out.handle == NULL) {
17580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17581                 }
17582                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17583                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17584         }
17585         return NDR_ERR_SUCCESS;
17586 }
17587
17588 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
17589 {
17590         TALLOC_CTX *_mem_save_handle_0;
17591         if (flags & NDR_IN) {
17592                 ZERO_STRUCT(r->out);
17593
17594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17595                         NDR_PULL_ALLOC(ndr, r->in.handle);
17596                 }
17597                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17598                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17599                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17601                 NDR_PULL_ALLOC(ndr, r->out.handle);
17602                 *r->out.handle = *r->in.handle;
17603         }
17604         if (flags & NDR_OUT) {
17605                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17606                         NDR_PULL_ALLOC(ndr, r->out.handle);
17607                 }
17608                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17609                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
17610                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17611                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17612                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17613         }
17614         return NDR_ERR_SUCCESS;
17615 }
17616
17617 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
17618 {
17619         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
17620         ndr->depth++;
17621         if (flags & NDR_SET_VALUES) {
17622                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17623         }
17624         if (flags & NDR_IN) {
17625                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
17626                 ndr->depth++;
17627                 ndr_print_ptr(ndr, "handle", r->in.handle);
17628                 ndr->depth++;
17629                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17630                 ndr->depth--;
17631                 ndr->depth--;
17632         }
17633         if (flags & NDR_OUT) {
17634                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
17635                 ndr->depth++;
17636                 ndr_print_ptr(ndr, "handle", r->out.handle);
17637                 ndr->depth++;
17638                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
17639                 ndr->depth--;
17640                 ndr_print_WERROR(ndr, "result", r->out.result);
17641                 ndr->depth--;
17642         }
17643         ndr->depth--;
17644 }
17645
17646 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
17647 {
17648         if (flags & NDR_IN) {
17649                 if (r->in.handle == NULL) {
17650                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17651                 }
17652                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17654                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
17655                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17656         }
17657         if (flags & NDR_OUT) {
17658                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17659         }
17660         return NDR_ERR_SUCCESS;
17661 }
17662
17663 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
17664 {
17665         TALLOC_CTX *_mem_save_handle_0;
17666         if (flags & NDR_IN) {
17667                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17668                         NDR_PULL_ALLOC(ndr, r->in.handle);
17669                 }
17670                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17671                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17672                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17673                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17675                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17676                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17677         }
17678         if (flags & NDR_OUT) {
17679                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17680         }
17681         return NDR_ERR_SUCCESS;
17682 }
17683
17684 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
17685 {
17686         ndr_print_struct(ndr, name, "spoolss_AddForm");
17687         ndr->depth++;
17688         if (flags & NDR_SET_VALUES) {
17689                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17690         }
17691         if (flags & NDR_IN) {
17692                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
17693                 ndr->depth++;
17694                 ndr_print_ptr(ndr, "handle", r->in.handle);
17695                 ndr->depth++;
17696                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17697                 ndr->depth--;
17698                 ndr_print_uint32(ndr, "level", r->in.level);
17699                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
17700                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
17701                 ndr->depth--;
17702         }
17703         if (flags & NDR_OUT) {
17704                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
17705                 ndr->depth++;
17706                 ndr_print_WERROR(ndr, "result", r->out.result);
17707                 ndr->depth--;
17708         }
17709         ndr->depth--;
17710 }
17711
17712 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
17713 {
17714         if (flags & NDR_IN) {
17715                 if (r->in.handle == NULL) {
17716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17717                 }
17718                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17722                 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));
17723         }
17724         if (flags & NDR_OUT) {
17725                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17726         }
17727         return NDR_ERR_SUCCESS;
17728 }
17729
17730 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
17731 {
17732         TALLOC_CTX *_mem_save_handle_0;
17733         if (flags & NDR_IN) {
17734                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17735                         NDR_PULL_ALLOC(ndr, r->in.handle);
17736                 }
17737                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17738                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17739                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17740                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17741                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
17742                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
17743                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
17744                         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));
17745                 }
17746                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
17747                 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));
17748         }
17749         if (flags & NDR_OUT) {
17750                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17751         }
17752         return NDR_ERR_SUCCESS;
17753 }
17754
17755 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
17756 {
17757         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
17758         ndr->depth++;
17759         if (flags & NDR_SET_VALUES) {
17760                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17761         }
17762         if (flags & NDR_IN) {
17763                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
17764                 ndr->depth++;
17765                 ndr_print_ptr(ndr, "handle", r->in.handle);
17766                 ndr->depth++;
17767                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17768                 ndr->depth--;
17769                 ndr_print_string(ndr, "form_name", r->in.form_name);
17770                 ndr->depth--;
17771         }
17772         if (flags & NDR_OUT) {
17773                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
17774                 ndr->depth++;
17775                 ndr_print_WERROR(ndr, "result", r->out.result);
17776                 ndr->depth--;
17777         }
17778         ndr->depth--;
17779 }
17780
17781 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
17782 {
17783         if (flags & NDR_IN) {
17784                 if (r->in.handle == NULL) {
17785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17786                 }
17787                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17791                 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));
17792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17793                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17794                 if (r->in.buffer) {
17795                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17796                 }
17797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17798         }
17799         if (flags & NDR_OUT) {
17800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17801                 if (r->out.info) {
17802                         {
17803                                 struct ndr_push *_ndr_info;
17804                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17805                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
17806                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17807                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17808                         }
17809                 }
17810                 if (r->out.needed == NULL) {
17811                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17812                 }
17813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17814                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17815         }
17816         return NDR_ERR_SUCCESS;
17817 }
17818
17819 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
17820 {
17821         uint32_t _ptr_buffer;
17822         uint32_t _ptr_info;
17823         TALLOC_CTX *_mem_save_handle_0;
17824         TALLOC_CTX *_mem_save_buffer_0;
17825         TALLOC_CTX *_mem_save_info_0;
17826         TALLOC_CTX *_mem_save_needed_0;
17827         if (flags & NDR_IN) {
17828                 ZERO_STRUCT(r->out);
17829
17830                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17831                         NDR_PULL_ALLOC(ndr, r->in.handle);
17832                 }
17833                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17834                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17835                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17836                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17837                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
17838                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
17839                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
17840                         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));
17841                 }
17842                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
17843                 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));
17844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17846                 if (_ptr_buffer) {
17847                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17848                 } else {
17849                         r->in.buffer = NULL;
17850                 }
17851                 if (r->in.buffer) {
17852                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17853                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17854                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17856                 }
17857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17858                 NDR_PULL_ALLOC(ndr, r->out.needed);
17859                 ZERO_STRUCTP(r->out.needed);
17860         }
17861         if (flags & NDR_OUT) {
17862                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17863                 if (_ptr_info) {
17864                         NDR_PULL_ALLOC(ndr, r->out.info);
17865                 } else {
17866                         r->out.info = NULL;
17867                 }
17868                 if (r->out.info) {
17869                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17870                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17871                         {
17872                                 struct ndr_pull *_ndr_info;
17873                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17874                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
17875                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17876                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17877                         }
17878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17879                 }
17880                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17881                         NDR_PULL_ALLOC(ndr, r->out.needed);
17882                 }
17883                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17884                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17886                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17887                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17888         }
17889         return NDR_ERR_SUCCESS;
17890 }
17891
17892 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
17893 {
17894         ndr_print_struct(ndr, name, "spoolss_GetForm");
17895         ndr->depth++;
17896         if (flags & NDR_SET_VALUES) {
17897                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17898         }
17899         if (flags & NDR_IN) {
17900                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
17901                 ndr->depth++;
17902                 ndr_print_ptr(ndr, "handle", r->in.handle);
17903                 ndr->depth++;
17904                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17905                 ndr->depth--;
17906                 ndr_print_string(ndr, "form_name", r->in.form_name);
17907                 ndr_print_uint32(ndr, "level", r->in.level);
17908                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17909                 ndr->depth++;
17910                 if (r->in.buffer) {
17911                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17912                 }
17913                 ndr->depth--;
17914                 ndr_print_uint32(ndr, "offered", r->in.offered);
17915                 ndr->depth--;
17916         }
17917         if (flags & NDR_OUT) {
17918                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
17919                 ndr->depth++;
17920                 ndr_print_ptr(ndr, "info", r->out.info);
17921                 ndr->depth++;
17922                 if (r->out.info) {
17923                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
17924                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
17925                 }
17926                 ndr->depth--;
17927                 ndr_print_ptr(ndr, "needed", r->out.needed);
17928                 ndr->depth++;
17929                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17930                 ndr->depth--;
17931                 ndr_print_WERROR(ndr, "result", r->out.result);
17932                 ndr->depth--;
17933         }
17934         ndr->depth--;
17935 }
17936
17937 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
17938 {
17939         if (flags & NDR_IN) {
17940                 if (r->in.handle == NULL) {
17941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17942                 }
17943                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17947                 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));
17948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17949                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
17950                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17951         }
17952         if (flags & NDR_OUT) {
17953                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17954         }
17955         return NDR_ERR_SUCCESS;
17956 }
17957
17958 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
17959 {
17960         TALLOC_CTX *_mem_save_handle_0;
17961         if (flags & NDR_IN) {
17962                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17963                         NDR_PULL_ALLOC(ndr, r->in.handle);
17964                 }
17965                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17966                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17967                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17968                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17969                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
17970                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
17971                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
17972                         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));
17973                 }
17974                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
17975                 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));
17976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17977                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17978                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17979         }
17980         if (flags & NDR_OUT) {
17981                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17982         }
17983         return NDR_ERR_SUCCESS;
17984 }
17985
17986 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
17987 {
17988         ndr_print_struct(ndr, name, "spoolss_SetForm");
17989         ndr->depth++;
17990         if (flags & NDR_SET_VALUES) {
17991                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17992         }
17993         if (flags & NDR_IN) {
17994                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
17995                 ndr->depth++;
17996                 ndr_print_ptr(ndr, "handle", r->in.handle);
17997                 ndr->depth++;
17998                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17999                 ndr->depth--;
18000                 ndr_print_string(ndr, "form_name", r->in.form_name);
18001                 ndr_print_uint32(ndr, "level", r->in.level);
18002                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18003                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18004                 ndr->depth--;
18005         }
18006         if (flags & NDR_OUT) {
18007                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
18008                 ndr->depth++;
18009                 ndr_print_WERROR(ndr, "result", r->out.result);
18010                 ndr->depth--;
18011         }
18012         ndr->depth--;
18013 }
18014
18015 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
18016 {
18017         if (flags & NDR_IN) {
18018                 if (r->in.handle == NULL) {
18019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18020                 }
18021                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18023                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18024                 if (r->in.buffer) {
18025                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18026                 }
18027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18028         }
18029         if (flags & NDR_OUT) {
18030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18031                 if (r->out.info) {
18032                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18033                 }
18034                 if (r->out.needed == NULL) {
18035                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18036                 }
18037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18038                 if (r->out.count == NULL) {
18039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18040                 }
18041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18043         }
18044         return NDR_ERR_SUCCESS;
18045 }
18046
18047 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
18048 {
18049         uint32_t _ptr_buffer;
18050         uint32_t _ptr_info;
18051         TALLOC_CTX *_mem_save_handle_0;
18052         TALLOC_CTX *_mem_save_buffer_0;
18053         TALLOC_CTX *_mem_save_info_0;
18054         TALLOC_CTX *_mem_save_needed_0;
18055         TALLOC_CTX *_mem_save_count_0;
18056         if (flags & NDR_IN) {
18057                 ZERO_STRUCT(r->out);
18058
18059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18060                         NDR_PULL_ALLOC(ndr, r->in.handle);
18061                 }
18062                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18063                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18064                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18068                 if (_ptr_buffer) {
18069                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18070                 } else {
18071                         r->in.buffer = NULL;
18072                 }
18073                 if (r->in.buffer) {
18074                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18075                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18076                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18078                 }
18079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18080                 NDR_PULL_ALLOC(ndr, r->out.needed);
18081                 ZERO_STRUCTP(r->out.needed);
18082                 NDR_PULL_ALLOC(ndr, r->out.count);
18083                 ZERO_STRUCTP(r->out.count);
18084         }
18085         if (flags & NDR_OUT) {
18086                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18087                 if (_ptr_info) {
18088                         NDR_PULL_ALLOC(ndr, r->out.info);
18089                 } else {
18090                         r->out.info = NULL;
18091                 }
18092                 if (r->out.info) {
18093                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18094                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18095                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18097                 }
18098                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18099                         NDR_PULL_ALLOC(ndr, r->out.needed);
18100                 }
18101                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18102                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18104                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18105                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18106                         NDR_PULL_ALLOC(ndr, r->out.count);
18107                 }
18108                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18109                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18111                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18112                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18113         }
18114         return NDR_ERR_SUCCESS;
18115 }
18116
18117 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
18118 {
18119         uint32_t cntr_info_0;
18120         if (flags & NDR_IN) {
18121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18123         }
18124         if (flags & NDR_OUT) {
18125                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18126                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18127                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18128                 }
18129                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18130                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18131                 }
18132         }
18133         return NDR_ERR_SUCCESS;
18134 }
18135
18136 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
18137 {
18138         uint32_t cntr_info_0;
18139         TALLOC_CTX *_mem_save_info_0;
18140         if (flags & NDR_IN) {
18141                 ZERO_STRUCT(r->out);
18142
18143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18145         }
18146         if (flags & NDR_OUT) {
18147                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18148                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18149                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18150                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18151                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18152                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18153                 }
18154                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18155                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18156                 }
18157                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18158         }
18159         return NDR_ERR_SUCCESS;
18160 }
18161
18162 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
18163 {
18164         uint32_t cntr_info_1;
18165         ndr_print_struct(ndr, name, "spoolss_EnumForms");
18166         ndr->depth++;
18167         if (flags & NDR_SET_VALUES) {
18168                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18169         }
18170         if (flags & NDR_IN) {
18171                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
18172                 ndr->depth++;
18173                 ndr_print_ptr(ndr, "handle", r->in.handle);
18174                 ndr->depth++;
18175                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18176                 ndr->depth--;
18177                 ndr_print_uint32(ndr, "level", r->in.level);
18178                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18179                 ndr->depth++;
18180                 if (r->in.buffer) {
18181                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18182                 }
18183                 ndr->depth--;
18184                 ndr_print_uint32(ndr, "offered", r->in.offered);
18185                 ndr->depth--;
18186         }
18187         if (flags & NDR_OUT) {
18188                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
18189                 ndr->depth++;
18190                 ndr_print_ptr(ndr, "count", r->out.count);
18191                 ndr->depth++;
18192                 ndr_print_uint32(ndr, "count", *r->out.count);
18193                 ndr->depth--;
18194                 ndr_print_ptr(ndr, "info", r->out.info);
18195                 ndr->depth++;
18196                 if (r->out.info) {
18197                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18198                         ndr->depth++;
18199                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18200                                 char *idx_1=NULL;
18201                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18202                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18203                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
18204                                         free(idx_1);
18205                                 }
18206                         }
18207                         ndr->depth--;
18208                 }
18209                 ndr->depth--;
18210                 ndr_print_ptr(ndr, "needed", r->out.needed);
18211                 ndr->depth++;
18212                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18213                 ndr->depth--;
18214                 ndr_print_WERROR(ndr, "result", r->out.result);
18215                 ndr->depth--;
18216         }
18217         ndr->depth--;
18218 }
18219
18220 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
18221 {
18222         if (flags & NDR_IN) {
18223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18224                 if (r->in.servername) {
18225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18227                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18228                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18229                 }
18230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18232                 if (r->in.buffer) {
18233                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18234                 }
18235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18236         }
18237         if (flags & NDR_OUT) {
18238                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18239                 if (r->out.info) {
18240                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18241                 }
18242                 if (r->out.needed == NULL) {
18243                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18244                 }
18245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18246                 if (r->out.count == NULL) {
18247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18248                 }
18249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18251         }
18252         return NDR_ERR_SUCCESS;
18253 }
18254
18255 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
18256 {
18257         uint32_t _ptr_servername;
18258         uint32_t _ptr_buffer;
18259         uint32_t _ptr_info;
18260         TALLOC_CTX *_mem_save_servername_0;
18261         TALLOC_CTX *_mem_save_buffer_0;
18262         TALLOC_CTX *_mem_save_info_0;
18263         TALLOC_CTX *_mem_save_needed_0;
18264         TALLOC_CTX *_mem_save_count_0;
18265         if (flags & NDR_IN) {
18266                 ZERO_STRUCT(r->out);
18267
18268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18269                 if (_ptr_servername) {
18270                         NDR_PULL_ALLOC(ndr, r->in.servername);
18271                 } else {
18272                         r->in.servername = NULL;
18273                 }
18274                 if (r->in.servername) {
18275                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18276                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18277                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18278                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18279                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18280                                 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));
18281                         }
18282                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18283                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18285                 }
18286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18287                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18288                 if (_ptr_buffer) {
18289                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18290                 } else {
18291                         r->in.buffer = NULL;
18292                 }
18293                 if (r->in.buffer) {
18294                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18295                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18296                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18298                 }
18299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18300                 NDR_PULL_ALLOC(ndr, r->out.needed);
18301                 ZERO_STRUCTP(r->out.needed);
18302                 NDR_PULL_ALLOC(ndr, r->out.count);
18303                 ZERO_STRUCTP(r->out.count);
18304         }
18305         if (flags & NDR_OUT) {
18306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18307                 if (_ptr_info) {
18308                         NDR_PULL_ALLOC(ndr, r->out.info);
18309                 } else {
18310                         r->out.info = NULL;
18311                 }
18312                 if (r->out.info) {
18313                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18314                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18315                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18317                 }
18318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18319                         NDR_PULL_ALLOC(ndr, r->out.needed);
18320                 }
18321                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18322                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18326                         NDR_PULL_ALLOC(ndr, r->out.count);
18327                 }
18328                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18329                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18332                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18333         }
18334         return NDR_ERR_SUCCESS;
18335 }
18336
18337 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
18338 {
18339         uint32_t cntr_info_0;
18340         if (flags & NDR_IN) {
18341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18343         }
18344         if (flags & NDR_OUT) {
18345                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18346                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18347                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18348                 }
18349                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18350                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18351                 }
18352         }
18353         return NDR_ERR_SUCCESS;
18354 }
18355
18356 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
18357 {
18358         uint32_t cntr_info_0;
18359         TALLOC_CTX *_mem_save_info_0;
18360         if (flags & NDR_IN) {
18361                 ZERO_STRUCT(r->out);
18362
18363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18365         }
18366         if (flags & NDR_OUT) {
18367                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18368                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18369                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18370                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18371                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18372                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18373                 }
18374                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18375                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18376                 }
18377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18378         }
18379         return NDR_ERR_SUCCESS;
18380 }
18381
18382 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
18383 {
18384         uint32_t cntr_info_1;
18385         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
18386         ndr->depth++;
18387         if (flags & NDR_SET_VALUES) {
18388                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18389         }
18390         if (flags & NDR_IN) {
18391                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
18392                 ndr->depth++;
18393                 ndr_print_ptr(ndr, "servername", r->in.servername);
18394                 ndr->depth++;
18395                 if (r->in.servername) {
18396                         ndr_print_string(ndr, "servername", r->in.servername);
18397                 }
18398                 ndr->depth--;
18399                 ndr_print_uint32(ndr, "level", r->in.level);
18400                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18401                 ndr->depth++;
18402                 if (r->in.buffer) {
18403                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18404                 }
18405                 ndr->depth--;
18406                 ndr_print_uint32(ndr, "offered", r->in.offered);
18407                 ndr->depth--;
18408         }
18409         if (flags & NDR_OUT) {
18410                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
18411                 ndr->depth++;
18412                 ndr_print_ptr(ndr, "count", r->out.count);
18413                 ndr->depth++;
18414                 ndr_print_uint32(ndr, "count", *r->out.count);
18415                 ndr->depth--;
18416                 ndr_print_ptr(ndr, "info", r->out.info);
18417                 ndr->depth++;
18418                 if (r->out.info) {
18419                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18420                         ndr->depth++;
18421                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18422                                 char *idx_1=NULL;
18423                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18424                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18425                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
18426                                         free(idx_1);
18427                                 }
18428                         }
18429                         ndr->depth--;
18430                 }
18431                 ndr->depth--;
18432                 ndr_print_ptr(ndr, "needed", r->out.needed);
18433                 ndr->depth++;
18434                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18435                 ndr->depth--;
18436                 ndr_print_WERROR(ndr, "result", r->out.result);
18437                 ndr->depth--;
18438         }
18439         ndr->depth--;
18440 }
18441
18442 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
18443 {
18444         if (flags & NDR_IN) {
18445                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18446                 if (r->in.servername) {
18447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18450                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18451                 }
18452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18454                 if (r->in.buffer) {
18455                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18456                 }
18457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18458         }
18459         if (flags & NDR_OUT) {
18460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18461                 if (r->out.info) {
18462                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18463                 }
18464                 if (r->out.needed == NULL) {
18465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18466                 }
18467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18468                 if (r->out.count == NULL) {
18469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18470                 }
18471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18472                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18473         }
18474         return NDR_ERR_SUCCESS;
18475 }
18476
18477 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
18478 {
18479         uint32_t _ptr_servername;
18480         uint32_t _ptr_buffer;
18481         uint32_t _ptr_info;
18482         TALLOC_CTX *_mem_save_servername_0;
18483         TALLOC_CTX *_mem_save_buffer_0;
18484         TALLOC_CTX *_mem_save_info_0;
18485         TALLOC_CTX *_mem_save_needed_0;
18486         TALLOC_CTX *_mem_save_count_0;
18487         if (flags & NDR_IN) {
18488                 ZERO_STRUCT(r->out);
18489
18490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18491                 if (_ptr_servername) {
18492                         NDR_PULL_ALLOC(ndr, r->in.servername);
18493                 } else {
18494                         r->in.servername = NULL;
18495                 }
18496                 if (r->in.servername) {
18497                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18498                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18499                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18500                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18501                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18502                                 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));
18503                         }
18504                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18505                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18507                 }
18508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18510                 if (_ptr_buffer) {
18511                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18512                 } else {
18513                         r->in.buffer = NULL;
18514                 }
18515                 if (r->in.buffer) {
18516                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18517                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18518                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18520                 }
18521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18522                 NDR_PULL_ALLOC(ndr, r->out.needed);
18523                 ZERO_STRUCTP(r->out.needed);
18524                 NDR_PULL_ALLOC(ndr, r->out.count);
18525                 ZERO_STRUCTP(r->out.count);
18526         }
18527         if (flags & NDR_OUT) {
18528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18529                 if (_ptr_info) {
18530                         NDR_PULL_ALLOC(ndr, r->out.info);
18531                 } else {
18532                         r->out.info = NULL;
18533                 }
18534                 if (r->out.info) {
18535                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18536                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18537                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18539                 }
18540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18541                         NDR_PULL_ALLOC(ndr, r->out.needed);
18542                 }
18543                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18544                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18548                         NDR_PULL_ALLOC(ndr, r->out.count);
18549                 }
18550                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18554                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18555         }
18556         return NDR_ERR_SUCCESS;
18557 }
18558
18559 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
18560 {
18561         uint32_t cntr_info_0;
18562         if (flags & NDR_IN) {
18563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18565         }
18566         if (flags & NDR_OUT) {
18567                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18568                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18569                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18570                 }
18571                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18572                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18573                 }
18574         }
18575         return NDR_ERR_SUCCESS;
18576 }
18577
18578 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
18579 {
18580         uint32_t cntr_info_0;
18581         TALLOC_CTX *_mem_save_info_0;
18582         if (flags & NDR_IN) {
18583                 ZERO_STRUCT(r->out);
18584
18585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18587         }
18588         if (flags & NDR_OUT) {
18589                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18590                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18591                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18592                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18593                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18594                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18595                 }
18596                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18597                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18598                 }
18599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18600         }
18601         return NDR_ERR_SUCCESS;
18602 }
18603
18604 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
18605 {
18606         uint32_t cntr_info_1;
18607         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
18608         ndr->depth++;
18609         if (flags & NDR_SET_VALUES) {
18610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18611         }
18612         if (flags & NDR_IN) {
18613                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
18614                 ndr->depth++;
18615                 ndr_print_ptr(ndr, "servername", r->in.servername);
18616                 ndr->depth++;
18617                 if (r->in.servername) {
18618                         ndr_print_string(ndr, "servername", r->in.servername);
18619                 }
18620                 ndr->depth--;
18621                 ndr_print_uint32(ndr, "level", r->in.level);
18622                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18623                 ndr->depth++;
18624                 if (r->in.buffer) {
18625                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18626                 }
18627                 ndr->depth--;
18628                 ndr_print_uint32(ndr, "offered", r->in.offered);
18629                 ndr->depth--;
18630         }
18631         if (flags & NDR_OUT) {
18632                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
18633                 ndr->depth++;
18634                 ndr_print_ptr(ndr, "count", r->out.count);
18635                 ndr->depth++;
18636                 ndr_print_uint32(ndr, "count", *r->out.count);
18637                 ndr->depth--;
18638                 ndr_print_ptr(ndr, "info", r->out.info);
18639                 ndr->depth++;
18640                 if (r->out.info) {
18641                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18642                         ndr->depth++;
18643                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18644                                 char *idx_1=NULL;
18645                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18646                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18647                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
18648                                         free(idx_1);
18649                                 }
18650                         }
18651                         ndr->depth--;
18652                 }
18653                 ndr->depth--;
18654                 ndr_print_ptr(ndr, "needed", r->out.needed);
18655                 ndr->depth++;
18656                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18657                 ndr->depth--;
18658                 ndr_print_WERROR(ndr, "result", r->out.result);
18659                 ndr->depth--;
18660         }
18661         ndr->depth--;
18662 }
18663
18664 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
18665 {
18666         if (flags & NDR_IN) {
18667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
18668                 if (r->in.server_name) {
18669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
18670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18671                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
18672                         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));
18673                 }
18674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
18675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
18676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
18678                 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));
18679         }
18680         if (flags & NDR_OUT) {
18681                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18682         }
18683         return NDR_ERR_SUCCESS;
18684 }
18685
18686 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
18687 {
18688         uint32_t _ptr_server_name;
18689         TALLOC_CTX *_mem_save_server_name_0;
18690         if (flags & NDR_IN) {
18691                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
18692                 if (_ptr_server_name) {
18693                         NDR_PULL_ALLOC(ndr, r->in.server_name);
18694                 } else {
18695                         r->in.server_name = NULL;
18696                 }
18697                 if (r->in.server_name) {
18698                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18699                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
18700                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
18701                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
18702                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
18703                                 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));
18704                         }
18705                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
18706                         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));
18707                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
18708                 }
18709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
18710                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
18711                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
18712                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
18713                         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));
18714                 }
18715                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
18716                 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));
18717         }
18718         if (flags & NDR_OUT) {
18719                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18720         }
18721         return NDR_ERR_SUCCESS;
18722 }
18723
18724 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
18725 {
18726         ndr_print_struct(ndr, name, "spoolss_AddPort");
18727         ndr->depth++;
18728         if (flags & NDR_SET_VALUES) {
18729                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18730         }
18731         if (flags & NDR_IN) {
18732                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
18733                 ndr->depth++;
18734                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
18735                 ndr->depth++;
18736                 if (r->in.server_name) {
18737                         ndr_print_string(ndr, "server_name", r->in.server_name);
18738                 }
18739                 ndr->depth--;
18740                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
18741                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
18742                 ndr->depth--;
18743         }
18744         if (flags & NDR_OUT) {
18745                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
18746                 ndr->depth++;
18747                 ndr_print_WERROR(ndr, "result", r->out.result);
18748                 ndr->depth--;
18749         }
18750         ndr->depth--;
18751 }
18752
18753 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
18754 {
18755         if (flags & NDR_IN) {
18756         }
18757         if (flags & NDR_OUT) {
18758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18759         }
18760         return NDR_ERR_SUCCESS;
18761 }
18762
18763 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
18764 {
18765         if (flags & NDR_IN) {
18766         }
18767         if (flags & NDR_OUT) {
18768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18769         }
18770         return NDR_ERR_SUCCESS;
18771 }
18772
18773 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
18774 {
18775         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
18776         ndr->depth++;
18777         if (flags & NDR_SET_VALUES) {
18778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18779         }
18780         if (flags & NDR_IN) {
18781                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
18782                 ndr->depth++;
18783                 ndr->depth--;
18784         }
18785         if (flags & NDR_OUT) {
18786                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
18787                 ndr->depth++;
18788                 ndr_print_WERROR(ndr, "result", r->out.result);
18789                 ndr->depth--;
18790         }
18791         ndr->depth--;
18792 }
18793
18794 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
18795 {
18796         if (flags & NDR_IN) {
18797         }
18798         if (flags & NDR_OUT) {
18799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18800         }
18801         return NDR_ERR_SUCCESS;
18802 }
18803
18804 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
18805 {
18806         if (flags & NDR_IN) {
18807         }
18808         if (flags & NDR_OUT) {
18809                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18810         }
18811         return NDR_ERR_SUCCESS;
18812 }
18813
18814 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
18815 {
18816         ndr_print_struct(ndr, name, "spoolss_DeletePort");
18817         ndr->depth++;
18818         if (flags & NDR_SET_VALUES) {
18819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18820         }
18821         if (flags & NDR_IN) {
18822                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
18823                 ndr->depth++;
18824                 ndr->depth--;
18825         }
18826         if (flags & NDR_OUT) {
18827                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
18828                 ndr->depth++;
18829                 ndr_print_WERROR(ndr, "result", r->out.result);
18830                 ndr->depth--;
18831         }
18832         ndr->depth--;
18833 }
18834
18835 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
18836 {
18837         if (flags & NDR_IN) {
18838         }
18839         if (flags & NDR_OUT) {
18840                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18841         }
18842         return NDR_ERR_SUCCESS;
18843 }
18844
18845 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
18846 {
18847         if (flags & NDR_IN) {
18848         }
18849         if (flags & NDR_OUT) {
18850                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18851         }
18852         return NDR_ERR_SUCCESS;
18853 }
18854
18855 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
18856 {
18857         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
18858         ndr->depth++;
18859         if (flags & NDR_SET_VALUES) {
18860                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18861         }
18862         if (flags & NDR_IN) {
18863                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
18864                 ndr->depth++;
18865                 ndr->depth--;
18866         }
18867         if (flags & NDR_OUT) {
18868                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
18869                 ndr->depth++;
18870                 ndr_print_WERROR(ndr, "result", r->out.result);
18871                 ndr->depth--;
18872         }
18873         ndr->depth--;
18874 }
18875
18876 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
18877 {
18878         if (flags & NDR_IN) {
18879         }
18880         if (flags & NDR_OUT) {
18881                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18882         }
18883         return NDR_ERR_SUCCESS;
18884 }
18885
18886 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
18887 {
18888         if (flags & NDR_IN) {
18889         }
18890         if (flags & NDR_OUT) {
18891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18892         }
18893         return NDR_ERR_SUCCESS;
18894 }
18895
18896 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
18897 {
18898         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
18899         ndr->depth++;
18900         if (flags & NDR_SET_VALUES) {
18901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18902         }
18903         if (flags & NDR_IN) {
18904                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
18905                 ndr->depth++;
18906                 ndr->depth--;
18907         }
18908         if (flags & NDR_OUT) {
18909                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
18910                 ndr->depth++;
18911                 ndr_print_WERROR(ndr, "result", r->out.result);
18912                 ndr->depth--;
18913         }
18914         ndr->depth--;
18915 }
18916
18917 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
18918 {
18919         if (flags & NDR_IN) {
18920         }
18921         if (flags & NDR_OUT) {
18922                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18923         }
18924         return NDR_ERR_SUCCESS;
18925 }
18926
18927 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
18928 {
18929         if (flags & NDR_IN) {
18930         }
18931         if (flags & NDR_OUT) {
18932                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18933         }
18934         return NDR_ERR_SUCCESS;
18935 }
18936
18937 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
18938 {
18939         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
18940         ndr->depth++;
18941         if (flags & NDR_SET_VALUES) {
18942                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18943         }
18944         if (flags & NDR_IN) {
18945                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
18946                 ndr->depth++;
18947                 ndr->depth--;
18948         }
18949         if (flags & NDR_OUT) {
18950                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
18951                 ndr->depth++;
18952                 ndr_print_WERROR(ndr, "result", r->out.result);
18953                 ndr->depth--;
18954         }
18955         ndr->depth--;
18956 }
18957
18958 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
18959 {
18960         if (flags & NDR_IN) {
18961         }
18962         if (flags & NDR_OUT) {
18963                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18964         }
18965         return NDR_ERR_SUCCESS;
18966 }
18967
18968 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
18969 {
18970         if (flags & NDR_IN) {
18971         }
18972         if (flags & NDR_OUT) {
18973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18974         }
18975         return NDR_ERR_SUCCESS;
18976 }
18977
18978 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
18979 {
18980         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
18981         ndr->depth++;
18982         if (flags & NDR_SET_VALUES) {
18983                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18984         }
18985         if (flags & NDR_IN) {
18986                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
18987                 ndr->depth++;
18988                 ndr->depth--;
18989         }
18990         if (flags & NDR_OUT) {
18991                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
18992                 ndr->depth++;
18993                 ndr_print_WERROR(ndr, "result", r->out.result);
18994                 ndr->depth--;
18995         }
18996         ndr->depth--;
18997 }
18998
18999 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
19000 {
19001         if (flags & NDR_IN) {
19002         }
19003         if (flags & NDR_OUT) {
19004                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19005         }
19006         return NDR_ERR_SUCCESS;
19007 }
19008
19009 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
19010 {
19011         if (flags & NDR_IN) {
19012         }
19013         if (flags & NDR_OUT) {
19014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19015         }
19016         return NDR_ERR_SUCCESS;
19017 }
19018
19019 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
19020 {
19021         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
19022         ndr->depth++;
19023         if (flags & NDR_SET_VALUES) {
19024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19025         }
19026         if (flags & NDR_IN) {
19027                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
19028                 ndr->depth++;
19029                 ndr->depth--;
19030         }
19031         if (flags & NDR_OUT) {
19032                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
19033                 ndr->depth++;
19034                 ndr_print_WERROR(ndr, "result", r->out.result);
19035                 ndr->depth--;
19036         }
19037         ndr->depth--;
19038 }
19039
19040 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
19041 {
19042         if (flags & NDR_IN) {
19043         }
19044         if (flags & NDR_OUT) {
19045                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19046         }
19047         return NDR_ERR_SUCCESS;
19048 }
19049
19050 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
19051 {
19052         if (flags & NDR_IN) {
19053         }
19054         if (flags & NDR_OUT) {
19055                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19056         }
19057         return NDR_ERR_SUCCESS;
19058 }
19059
19060 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
19061 {
19062         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
19063         ndr->depth++;
19064         if (flags & NDR_SET_VALUES) {
19065                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19066         }
19067         if (flags & NDR_IN) {
19068                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
19069                 ndr->depth++;
19070                 ndr->depth--;
19071         }
19072         if (flags & NDR_OUT) {
19073                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
19074                 ndr->depth++;
19075                 ndr_print_WERROR(ndr, "result", r->out.result);
19076                 ndr->depth--;
19077         }
19078         ndr->depth--;
19079 }
19080
19081 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
19082 {
19083         if (flags & NDR_IN) {
19084         }
19085         if (flags & NDR_OUT) {
19086                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19087         }
19088         return NDR_ERR_SUCCESS;
19089 }
19090
19091 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
19092 {
19093         if (flags & NDR_IN) {
19094         }
19095         if (flags & NDR_OUT) {
19096                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19097         }
19098         return NDR_ERR_SUCCESS;
19099 }
19100
19101 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
19102 {
19103         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
19104         ndr->depth++;
19105         if (flags & NDR_SET_VALUES) {
19106                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19107         }
19108         if (flags & NDR_IN) {
19109                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
19110                 ndr->depth++;
19111                 ndr->depth--;
19112         }
19113         if (flags & NDR_OUT) {
19114                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
19115                 ndr->depth++;
19116                 ndr_print_WERROR(ndr, "result", r->out.result);
19117                 ndr->depth--;
19118         }
19119         ndr->depth--;
19120 }
19121
19122 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
19123 {
19124         if (flags & NDR_IN) {
19125         }
19126         if (flags & NDR_OUT) {
19127                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19128         }
19129         return NDR_ERR_SUCCESS;
19130 }
19131
19132 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
19133 {
19134         if (flags & NDR_IN) {
19135         }
19136         if (flags & NDR_OUT) {
19137                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19138         }
19139         return NDR_ERR_SUCCESS;
19140 }
19141
19142 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
19143 {
19144         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
19145         ndr->depth++;
19146         if (flags & NDR_SET_VALUES) {
19147                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19148         }
19149         if (flags & NDR_IN) {
19150                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
19151                 ndr->depth++;
19152                 ndr->depth--;
19153         }
19154         if (flags & NDR_OUT) {
19155                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
19156                 ndr->depth++;
19157                 ndr_print_WERROR(ndr, "result", r->out.result);
19158                 ndr->depth--;
19159         }
19160         ndr->depth--;
19161 }
19162
19163 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
19164 {
19165         if (flags & NDR_IN) {
19166         }
19167         if (flags & NDR_OUT) {
19168                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19169         }
19170         return NDR_ERR_SUCCESS;
19171 }
19172
19173 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
19174 {
19175         if (flags & NDR_IN) {
19176         }
19177         if (flags & NDR_OUT) {
19178                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19179         }
19180         return NDR_ERR_SUCCESS;
19181 }
19182
19183 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
19184 {
19185         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
19186         ndr->depth++;
19187         if (flags & NDR_SET_VALUES) {
19188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19189         }
19190         if (flags & NDR_IN) {
19191                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
19192                 ndr->depth++;
19193                 ndr->depth--;
19194         }
19195         if (flags & NDR_OUT) {
19196                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
19197                 ndr->depth++;
19198                 ndr_print_WERROR(ndr, "result", r->out.result);
19199                 ndr->depth--;
19200         }
19201         ndr->depth--;
19202 }
19203
19204 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
19205 {
19206         if (flags & NDR_IN) {
19207         }
19208         if (flags & NDR_OUT) {
19209                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19210         }
19211         return NDR_ERR_SUCCESS;
19212 }
19213
19214 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
19215 {
19216         if (flags & NDR_IN) {
19217         }
19218         if (flags & NDR_OUT) {
19219                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19220         }
19221         return NDR_ERR_SUCCESS;
19222 }
19223
19224 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
19225 {
19226         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
19227         ndr->depth++;
19228         if (flags & NDR_SET_VALUES) {
19229                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19230         }
19231         if (flags & NDR_IN) {
19232                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
19233                 ndr->depth++;
19234                 ndr->depth--;
19235         }
19236         if (flags & NDR_OUT) {
19237                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
19238                 ndr->depth++;
19239                 ndr_print_WERROR(ndr, "result", r->out.result);
19240                 ndr->depth--;
19241         }
19242         ndr->depth--;
19243 }
19244
19245 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
19246 {
19247         if (flags & NDR_IN) {
19248         }
19249         if (flags & NDR_OUT) {
19250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19251         }
19252         return NDR_ERR_SUCCESS;
19253 }
19254
19255 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
19256 {
19257         if (flags & NDR_IN) {
19258         }
19259         if (flags & NDR_OUT) {
19260                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19261         }
19262         return NDR_ERR_SUCCESS;
19263 }
19264
19265 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
19266 {
19267         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
19268         ndr->depth++;
19269         if (flags & NDR_SET_VALUES) {
19270                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19271         }
19272         if (flags & NDR_IN) {
19273                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
19274                 ndr->depth++;
19275                 ndr->depth--;
19276         }
19277         if (flags & NDR_OUT) {
19278                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
19279                 ndr->depth++;
19280                 ndr_print_WERROR(ndr, "result", r->out.result);
19281                 ndr->depth--;
19282         }
19283         ndr->depth--;
19284 }
19285
19286 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19287 {
19288         if (flags & NDR_IN) {
19289         }
19290         if (flags & NDR_OUT) {
19291                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19292         }
19293         return NDR_ERR_SUCCESS;
19294 }
19295
19296 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
19297 {
19298         if (flags & NDR_IN) {
19299         }
19300         if (flags & NDR_OUT) {
19301                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19302         }
19303         return NDR_ERR_SUCCESS;
19304 }
19305
19306 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19307 {
19308         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
19309         ndr->depth++;
19310         if (flags & NDR_SET_VALUES) {
19311                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19312         }
19313         if (flags & NDR_IN) {
19314                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
19315                 ndr->depth++;
19316                 ndr->depth--;
19317         }
19318         if (flags & NDR_OUT) {
19319                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
19320                 ndr->depth++;
19321                 ndr_print_WERROR(ndr, "result", r->out.result);
19322                 ndr->depth--;
19323         }
19324         ndr->depth--;
19325 }
19326
19327 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
19328 {
19329         if (flags & NDR_IN) {
19330                 if (r->in.handle == NULL) {
19331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19332                 }
19333                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
19335                 if (r->in.data_type) {
19336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19339                         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));
19340                 }
19341                 if (r->in.devmode_ctr == NULL) {
19342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19343                 }
19344                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19345         }
19346         if (flags & NDR_OUT) {
19347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19348         }
19349         return NDR_ERR_SUCCESS;
19350 }
19351
19352 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
19353 {
19354         uint32_t _ptr_data_type;
19355         TALLOC_CTX *_mem_save_handle_0;
19356         TALLOC_CTX *_mem_save_data_type_0;
19357         TALLOC_CTX *_mem_save_devmode_ctr_0;
19358         if (flags & NDR_IN) {
19359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19360                         NDR_PULL_ALLOC(ndr, r->in.handle);
19361                 }
19362                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19363                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19364                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
19367                 if (_ptr_data_type) {
19368                         NDR_PULL_ALLOC(ndr, r->in.data_type);
19369                 } else {
19370                         r->in.data_type = NULL;
19371                 }
19372                 if (r->in.data_type) {
19373                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
19374                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
19375                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
19376                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
19377                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
19378                                 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));
19379                         }
19380                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
19381                         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));
19382                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
19383                 }
19384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19385                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19386                 }
19387                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19388                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19389                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19391         }
19392         if (flags & NDR_OUT) {
19393                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19394         }
19395         return NDR_ERR_SUCCESS;
19396 }
19397
19398 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
19399 {
19400         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
19401         ndr->depth++;
19402         if (flags & NDR_SET_VALUES) {
19403                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19404         }
19405         if (flags & NDR_IN) {
19406                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
19407                 ndr->depth++;
19408                 ndr_print_ptr(ndr, "handle", r->in.handle);
19409                 ndr->depth++;
19410                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19411                 ndr->depth--;
19412                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
19413                 ndr->depth++;
19414                 if (r->in.data_type) {
19415                         ndr_print_string(ndr, "data_type", r->in.data_type);
19416                 }
19417                 ndr->depth--;
19418                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19419                 ndr->depth++;
19420                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19421                 ndr->depth--;
19422                 ndr->depth--;
19423         }
19424         if (flags & NDR_OUT) {
19425                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
19426                 ndr->depth++;
19427                 ndr_print_WERROR(ndr, "result", r->out.result);
19428                 ndr->depth--;
19429         }
19430         ndr->depth--;
19431 }
19432
19433 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
19434 {
19435         if (flags & NDR_IN) {
19436                 if (r->in.handle == NULL) {
19437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19438                 }
19439                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
19441                 if (r->in.architecture) {
19442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19446                 }
19447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19449                 if (r->in.buffer) {
19450                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19451                 }
19452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
19454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
19455         }
19456         if (flags & NDR_OUT) {
19457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19458                 if (r->out.info) {
19459                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19460                 }
19461                 if (r->out.needed == NULL) {
19462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19463                 }
19464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19465                 if (r->out.server_major_version == NULL) {
19466                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19467                 }
19468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
19469                 if (r->out.server_minor_version == NULL) {
19470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19471                 }
19472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
19473                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19474         }
19475         return NDR_ERR_SUCCESS;
19476 }
19477
19478 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
19479 {
19480         uint32_t _ptr_architecture;
19481         uint32_t _ptr_buffer;
19482         uint32_t _ptr_info;
19483         TALLOC_CTX *_mem_save_handle_0;
19484         TALLOC_CTX *_mem_save_architecture_0;
19485         TALLOC_CTX *_mem_save_buffer_0;
19486         TALLOC_CTX *_mem_save_info_0;
19487         TALLOC_CTX *_mem_save_needed_0;
19488         TALLOC_CTX *_mem_save_server_major_version_0;
19489         TALLOC_CTX *_mem_save_server_minor_version_0;
19490         if (flags & NDR_IN) {
19491                 ZERO_STRUCT(r->out);
19492
19493                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19494                         NDR_PULL_ALLOC(ndr, r->in.handle);
19495                 }
19496                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19497                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19498                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19499                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
19501                 if (_ptr_architecture) {
19502                         NDR_PULL_ALLOC(ndr, r->in.architecture);
19503                 } else {
19504                         r->in.architecture = NULL;
19505                 }
19506                 if (r->in.architecture) {
19507                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
19508                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
19509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
19510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
19511                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
19512                                 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));
19513                         }
19514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
19515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
19516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
19517                 }
19518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19520                 if (_ptr_buffer) {
19521                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19522                 } else {
19523                         r->in.buffer = NULL;
19524                 }
19525                 if (r->in.buffer) {
19526                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19527                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19528                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19530                 }
19531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
19533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
19534                 NDR_PULL_ALLOC(ndr, r->out.needed);
19535                 ZERO_STRUCTP(r->out.needed);
19536                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19537                 ZERO_STRUCTP(r->out.server_major_version);
19538                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19539                 ZERO_STRUCTP(r->out.server_minor_version);
19540         }
19541         if (flags & NDR_OUT) {
19542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19543                 if (_ptr_info) {
19544                         NDR_PULL_ALLOC(ndr, r->out.info);
19545                 } else {
19546                         r->out.info = NULL;
19547                 }
19548                 if (r->out.info) {
19549                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19550                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19551                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19553                 }
19554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19555                         NDR_PULL_ALLOC(ndr, r->out.needed);
19556                 }
19557                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19558                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19561                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19562                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19563                 }
19564                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19565                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
19566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
19567                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
19568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19569                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19570                 }
19571                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19572                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
19573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
19574                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
19575                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19576         }
19577         return NDR_ERR_SUCCESS;
19578 }
19579
19580 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
19581 {
19582         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
19583         ndr->depth++;
19584         if (flags & NDR_SET_VALUES) {
19585                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19586         }
19587         if (flags & NDR_IN) {
19588                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
19589                 ndr->depth++;
19590                 ndr_print_ptr(ndr, "handle", r->in.handle);
19591                 ndr->depth++;
19592                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19593                 ndr->depth--;
19594                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
19595                 ndr->depth++;
19596                 if (r->in.architecture) {
19597                         ndr_print_string(ndr, "architecture", r->in.architecture);
19598                 }
19599                 ndr->depth--;
19600                 ndr_print_uint32(ndr, "level", r->in.level);
19601                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19602                 ndr->depth++;
19603                 if (r->in.buffer) {
19604                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19605                 }
19606                 ndr->depth--;
19607                 ndr_print_uint32(ndr, "offered", r->in.offered);
19608                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
19609                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
19610                 ndr->depth--;
19611         }
19612         if (flags & NDR_OUT) {
19613                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
19614                 ndr->depth++;
19615                 ndr_print_ptr(ndr, "info", r->out.info);
19616                 ndr->depth++;
19617                 if (r->out.info) {
19618                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
19619                 }
19620                 ndr->depth--;
19621                 ndr_print_ptr(ndr, "needed", r->out.needed);
19622                 ndr->depth++;
19623                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19624                 ndr->depth--;
19625                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
19626                 ndr->depth++;
19627                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
19628                 ndr->depth--;
19629                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
19630                 ndr->depth++;
19631                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
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_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *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_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *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_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
19660 {
19661         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
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_FindFirstPrinterChangeNotification");
19668                 ndr->depth++;
19669                 ndr->depth--;
19670         }
19671         if (flags & NDR_OUT) {
19672                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
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_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *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_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *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_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
19701 {
19702         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
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_FindNextPrinterChangeNotification");
19709                 ndr->depth++;
19710                 ndr->depth--;
19711         }
19712         if (flags & NDR_OUT) {
19713                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
19714                 ndr->depth++;
19715                 ndr_print_WERROR(ndr, "result", r->out.result);
19716                 ndr->depth--;
19717         }
19718         ndr->depth--;
19719 }
19720
19721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
19722 {
19723         if (flags & NDR_IN) {
19724                 if (r->in.handle == NULL) {
19725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19726                 }
19727                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19728         }
19729         if (flags & NDR_OUT) {
19730                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19731         }
19732         return NDR_ERR_SUCCESS;
19733 }
19734
19735 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
19736 {
19737         TALLOC_CTX *_mem_save_handle_0;
19738         if (flags & NDR_IN) {
19739                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19740                         NDR_PULL_ALLOC(ndr, r->in.handle);
19741                 }
19742                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19743                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19744                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19745                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19746         }
19747         if (flags & NDR_OUT) {
19748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19749         }
19750         return NDR_ERR_SUCCESS;
19751 }
19752
19753 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
19754 {
19755         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
19756         ndr->depth++;
19757         if (flags & NDR_SET_VALUES) {
19758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19759         }
19760         if (flags & NDR_IN) {
19761                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
19762                 ndr->depth++;
19763                 ndr_print_ptr(ndr, "handle", r->in.handle);
19764                 ndr->depth++;
19765                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19766                 ndr->depth--;
19767                 ndr->depth--;
19768         }
19769         if (flags & NDR_OUT) {
19770                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
19771                 ndr->depth++;
19772                 ndr_print_WERROR(ndr, "result", r->out.result);
19773                 ndr->depth--;
19774         }
19775         ndr->depth--;
19776 }
19777
19778 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
19779 {
19780         if (flags & NDR_IN) {
19781         }
19782         if (flags & NDR_OUT) {
19783                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19784         }
19785         return NDR_ERR_SUCCESS;
19786 }
19787
19788 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
19789 {
19790         if (flags & NDR_IN) {
19791         }
19792         if (flags & NDR_OUT) {
19793                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19794         }
19795         return NDR_ERR_SUCCESS;
19796 }
19797
19798 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
19799 {
19800         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
19801         ndr->depth++;
19802         if (flags & NDR_SET_VALUES) {
19803                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19804         }
19805         if (flags & NDR_IN) {
19806                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
19807                 ndr->depth++;
19808                 ndr->depth--;
19809         }
19810         if (flags & NDR_OUT) {
19811                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
19812                 ndr->depth++;
19813                 ndr_print_WERROR(ndr, "result", r->out.result);
19814                 ndr->depth--;
19815         }
19816         ndr->depth--;
19817 }
19818
19819 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
19820 {
19821         if (flags & NDR_IN) {
19822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19825                 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));
19826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
19827                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
19828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
19829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19830                 if (r->in.buffer) {
19831                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
19832                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
19833                 }
19834         }
19835         if (flags & NDR_OUT) {
19836                 if (r->out.handle == NULL) {
19837                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19838                 }
19839                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19840                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19841         }
19842         return NDR_ERR_SUCCESS;
19843 }
19844
19845 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
19846 {
19847         uint32_t _ptr_buffer;
19848         TALLOC_CTX *_mem_save_buffer_0;
19849         TALLOC_CTX *_mem_save_handle_0;
19850         if (flags & NDR_IN) {
19851                 ZERO_STRUCT(r->out);
19852
19853                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
19854                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
19855                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
19856                         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));
19857                 }
19858                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
19859                 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));
19860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
19861                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
19862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
19863                 if (r->in.bufsize > 512) {
19864                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
19865                 }
19866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19867                 if (_ptr_buffer) {
19868                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19869                 } else {
19870                         r->in.buffer = NULL;
19871                 }
19872                 if (r->in.buffer) {
19873                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19874                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
19876                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
19877                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
19878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19879                 }
19880                 NDR_PULL_ALLOC(ndr, r->out.handle);
19881                 ZERO_STRUCTP(r->out.handle);
19882                 if (r->in.buffer) {
19883                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
19884                 }
19885         }
19886         if (flags & NDR_OUT) {
19887                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19888                         NDR_PULL_ALLOC(ndr, r->out.handle);
19889                 }
19890                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19891                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19892                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19893                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19894                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19895         }
19896         return NDR_ERR_SUCCESS;
19897 }
19898
19899 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
19900 {
19901         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
19902         ndr->depth++;
19903         if (flags & NDR_SET_VALUES) {
19904                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19905         }
19906         if (flags & NDR_IN) {
19907                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
19908                 ndr->depth++;
19909                 ndr_print_string(ndr, "server_name", r->in.server_name);
19910                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
19911                 ndr_print_winreg_Type(ndr, "type", r->in.type);
19912                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
19913                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19914                 ndr->depth++;
19915                 if (r->in.buffer) {
19916                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
19917                 }
19918                 ndr->depth--;
19919                 ndr->depth--;
19920         }
19921         if (flags & NDR_OUT) {
19922                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
19923                 ndr->depth++;
19924                 ndr_print_ptr(ndr, "handle", r->out.handle);
19925                 ndr->depth++;
19926                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19927                 ndr->depth--;
19928                 ndr_print_WERROR(ndr, "result", r->out.result);
19929                 ndr->depth--;
19930         }
19931         ndr->depth--;
19932 }
19933
19934 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
19935 {
19936         if (flags & NDR_IN) {
19937                 if (r->in.handle == NULL) {
19938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19939                 }
19940                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19941                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
19942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
19943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19944                 if (r->in.buffer) {
19945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
19946                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
19947                 }
19948         }
19949         if (flags & NDR_OUT) {
19950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19951         }
19952         return NDR_ERR_SUCCESS;
19953 }
19954
19955 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
19956 {
19957         uint32_t _ptr_buffer;
19958         TALLOC_CTX *_mem_save_handle_0;
19959         TALLOC_CTX *_mem_save_buffer_0;
19960         if (flags & NDR_IN) {
19961                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19962                         NDR_PULL_ALLOC(ndr, r->in.handle);
19963                 }
19964                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19965                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19966                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19967                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19968                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
19969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
19970                 if (r->in.bufsize > 512) {
19971                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
19972                 }
19973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19974                 if (_ptr_buffer) {
19975                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19976                 } else {
19977                         r->in.buffer = NULL;
19978                 }
19979                 if (r->in.buffer) {
19980                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19981                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
19983                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
19984                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
19985                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19986                 }
19987                 if (r->in.buffer) {
19988                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
19989                 }
19990         }
19991         if (flags & NDR_OUT) {
19992                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19993         }
19994         return NDR_ERR_SUCCESS;
19995 }
19996
19997 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
19998 {
19999         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
20000         ndr->depth++;
20001         if (flags & NDR_SET_VALUES) {
20002                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20003         }
20004         if (flags & NDR_IN) {
20005                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
20006                 ndr->depth++;
20007                 ndr_print_ptr(ndr, "handle", r->in.handle);
20008                 ndr->depth++;
20009                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20010                 ndr->depth--;
20011                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20012                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20013                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20014                 ndr->depth++;
20015                 if (r->in.buffer) {
20016                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20017                 }
20018                 ndr->depth--;
20019                 ndr->depth--;
20020         }
20021         if (flags & NDR_OUT) {
20022                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
20023                 ndr->depth++;
20024                 ndr_print_WERROR(ndr, "result", r->out.result);
20025                 ndr->depth--;
20026         }
20027         ndr->depth--;
20028 }
20029
20030 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
20031 {
20032         if (flags & NDR_IN) {
20033                 if (r->in.handle == NULL) {
20034                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20035                 }
20036                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20037         }
20038         if (flags & NDR_OUT) {
20039                 if (r->out.handle == NULL) {
20040                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20041                 }
20042                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20043                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20044         }
20045         return NDR_ERR_SUCCESS;
20046 }
20047
20048 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
20049 {
20050         TALLOC_CTX *_mem_save_handle_0;
20051         if (flags & NDR_IN) {
20052                 ZERO_STRUCT(r->out);
20053
20054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20055                         NDR_PULL_ALLOC(ndr, r->in.handle);
20056                 }
20057                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20058                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20059                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20061                 NDR_PULL_ALLOC(ndr, r->out.handle);
20062                 *r->out.handle = *r->in.handle;
20063         }
20064         if (flags & NDR_OUT) {
20065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20066                         NDR_PULL_ALLOC(ndr, r->out.handle);
20067                 }
20068                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20069                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20070                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20073         }
20074         return NDR_ERR_SUCCESS;
20075 }
20076
20077 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
20078 {
20079         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
20080         ndr->depth++;
20081         if (flags & NDR_SET_VALUES) {
20082                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20083         }
20084         if (flags & NDR_IN) {
20085                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
20086                 ndr->depth++;
20087                 ndr_print_ptr(ndr, "handle", r->in.handle);
20088                 ndr->depth++;
20089                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20090                 ndr->depth--;
20091                 ndr->depth--;
20092         }
20093         if (flags & NDR_OUT) {
20094                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
20095                 ndr->depth++;
20096                 ndr_print_ptr(ndr, "handle", r->out.handle);
20097                 ndr->depth++;
20098                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20099                 ndr->depth--;
20100                 ndr_print_WERROR(ndr, "result", r->out.result);
20101                 ndr->depth--;
20102         }
20103         ndr->depth--;
20104 }
20105
20106 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
20107 {
20108         if (flags & NDR_IN) {
20109         }
20110         if (flags & NDR_OUT) {
20111                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20112         }
20113         return NDR_ERR_SUCCESS;
20114 }
20115
20116 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
20117 {
20118         if (flags & NDR_IN) {
20119         }
20120         if (flags & NDR_OUT) {
20121                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20122         }
20123         return NDR_ERR_SUCCESS;
20124 }
20125
20126 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
20127 {
20128         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
20129         ndr->depth++;
20130         if (flags & NDR_SET_VALUES) {
20131                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20132         }
20133         if (flags & NDR_IN) {
20134                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
20135                 ndr->depth++;
20136                 ndr->depth--;
20137         }
20138         if (flags & NDR_OUT) {
20139                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
20140                 ndr->depth++;
20141                 ndr_print_WERROR(ndr, "result", r->out.result);
20142                 ndr->depth--;
20143         }
20144         ndr->depth--;
20145 }
20146
20147 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20148 {
20149         if (flags & NDR_IN) {
20150         }
20151         if (flags & NDR_OUT) {
20152                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20153         }
20154         return NDR_ERR_SUCCESS;
20155 }
20156
20157 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20158 {
20159         if (flags & NDR_IN) {
20160         }
20161         if (flags & NDR_OUT) {
20162                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20163         }
20164         return NDR_ERR_SUCCESS;
20165 }
20166
20167 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20168 {
20169         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
20170         ndr->depth++;
20171         if (flags & NDR_SET_VALUES) {
20172                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20173         }
20174         if (flags & NDR_IN) {
20175                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
20176                 ndr->depth++;
20177                 ndr->depth--;
20178         }
20179         if (flags & NDR_OUT) {
20180                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
20181                 ndr->depth++;
20182                 ndr_print_WERROR(ndr, "result", r->out.result);
20183                 ndr->depth--;
20184         }
20185         ndr->depth--;
20186 }
20187
20188 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
20189 {
20190         if (flags & NDR_IN) {
20191         }
20192         if (flags & NDR_OUT) {
20193                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20194         }
20195         return NDR_ERR_SUCCESS;
20196 }
20197
20198 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
20199 {
20200         if (flags & NDR_IN) {
20201         }
20202         if (flags & NDR_OUT) {
20203                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20204         }
20205         return NDR_ERR_SUCCESS;
20206 }
20207
20208 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
20209 {
20210         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
20211         ndr->depth++;
20212         if (flags & NDR_SET_VALUES) {
20213                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20214         }
20215         if (flags & NDR_IN) {
20216                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
20217                 ndr->depth++;
20218                 ndr->depth--;
20219         }
20220         if (flags & NDR_OUT) {
20221                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
20222                 ndr->depth++;
20223                 ndr_print_WERROR(ndr, "result", r->out.result);
20224                 ndr->depth--;
20225         }
20226         ndr->depth--;
20227 }
20228
20229 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
20230 {
20231         if (flags & NDR_IN) {
20232         }
20233         if (flags & NDR_OUT) {
20234                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20235         }
20236         return NDR_ERR_SUCCESS;
20237 }
20238
20239 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
20240 {
20241         if (flags & NDR_IN) {
20242         }
20243         if (flags & NDR_OUT) {
20244                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20245         }
20246         return NDR_ERR_SUCCESS;
20247 }
20248
20249 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
20250 {
20251         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
20252         ndr->depth++;
20253         if (flags & NDR_SET_VALUES) {
20254                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20255         }
20256         if (flags & NDR_IN) {
20257                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
20258                 ndr->depth++;
20259                 ndr->depth--;
20260         }
20261         if (flags & NDR_OUT) {
20262                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
20263                 ndr->depth++;
20264                 ndr_print_WERROR(ndr, "result", r->out.result);
20265                 ndr->depth--;
20266         }
20267         ndr->depth--;
20268 }
20269
20270 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20271 {
20272         if (flags & NDR_IN) {
20273                 if (r->in.handle == NULL) {
20274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20275                 }
20276                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20277                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
20279                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
20280                 if (r->in.local_machine) {
20281                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20282                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20283                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20284                         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));
20285                 }
20286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
20288                 if (r->in.notify_options) {
20289                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20290                 }
20291         }
20292         if (flags & NDR_OUT) {
20293                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20294         }
20295         return NDR_ERR_SUCCESS;
20296 }
20297
20298 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20299 {
20300         uint32_t _ptr_local_machine;
20301         uint32_t _ptr_notify_options;
20302         TALLOC_CTX *_mem_save_handle_0;
20303         TALLOC_CTX *_mem_save_local_machine_0;
20304         TALLOC_CTX *_mem_save_notify_options_0;
20305         if (flags & NDR_IN) {
20306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20307                         NDR_PULL_ALLOC(ndr, r->in.handle);
20308                 }
20309                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20310                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20311                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20312                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20313                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
20315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
20316                 if (_ptr_local_machine) {
20317                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
20318                 } else {
20319                         r->in.local_machine = NULL;
20320                 }
20321                 if (r->in.local_machine) {
20322                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
20323                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
20324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
20325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
20326                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
20327                                 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));
20328                         }
20329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
20330                         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));
20331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
20332                 }
20333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
20335                 if (_ptr_notify_options) {
20336                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
20337                 } else {
20338                         r->in.notify_options = NULL;
20339                 }
20340                 if (r->in.notify_options) {
20341                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20342                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
20343                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20344                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
20345                 }
20346         }
20347         if (flags & NDR_OUT) {
20348                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20349         }
20350         return NDR_ERR_SUCCESS;
20351 }
20352
20353 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20354 {
20355         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20356         ndr->depth++;
20357         if (flags & NDR_SET_VALUES) {
20358                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20359         }
20360         if (flags & NDR_IN) {
20361                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20362                 ndr->depth++;
20363                 ndr_print_ptr(ndr, "handle", r->in.handle);
20364                 ndr->depth++;
20365                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20366                 ndr->depth--;
20367                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20368                 ndr_print_uint32(ndr, "options", r->in.options);
20369                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
20370                 ndr->depth++;
20371                 if (r->in.local_machine) {
20372                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
20373                 }
20374                 ndr->depth--;
20375                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20376                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
20377                 ndr->depth++;
20378                 if (r->in.notify_options) {
20379                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
20380                 }
20381                 ndr->depth--;
20382                 ndr->depth--;
20383         }
20384         if (flags & NDR_OUT) {
20385                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20386                 ndr->depth++;
20387                 ndr_print_WERROR(ndr, "result", r->out.result);
20388                 ndr->depth--;
20389         }
20390         ndr->depth--;
20391 }
20392
20393 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20394 {
20395         if (flags & NDR_IN) {
20396                 if (r->in.handle == NULL) {
20397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20398                 }
20399                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
20401                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
20403                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20404                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20405         }
20406         if (flags & NDR_OUT) {
20407                 if (r->out.reply_result == NULL) {
20408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20409                 }
20410                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
20411                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20412         }
20413         return NDR_ERR_SUCCESS;
20414 }
20415
20416 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
20417 {
20418         TALLOC_CTX *_mem_save_handle_0;
20419         TALLOC_CTX *_mem_save_reply_result_0;
20420         if (flags & NDR_IN) {
20421                 ZERO_STRUCT(r->out);
20422
20423                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20424                         NDR_PULL_ALLOC(ndr, r->in.handle);
20425                 }
20426                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20427                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20428                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
20431                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
20433                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20434                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20435                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
20436                 ZERO_STRUCTP(r->out.reply_result);
20437         }
20438         if (flags & NDR_OUT) {
20439                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20440                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
20441                 }
20442                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
20443                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
20444                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
20445                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
20446                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20447         }
20448         return NDR_ERR_SUCCESS;
20449 }
20450
20451 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20452 {
20453         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
20454         ndr->depth++;
20455         if (flags & NDR_SET_VALUES) {
20456                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20457         }
20458         if (flags & NDR_IN) {
20459                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
20460                 ndr->depth++;
20461                 ndr_print_ptr(ndr, "handle", r->in.handle);
20462                 ndr->depth++;
20463                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20464                 ndr->depth--;
20465                 ndr_print_uint32(ndr, "color", r->in.color);
20466                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20467                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
20468                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
20469                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
20470                 ndr->depth--;
20471         }
20472         if (flags & NDR_OUT) {
20473                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
20474                 ndr->depth++;
20475                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
20476                 ndr->depth++;
20477                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
20478                 ndr->depth--;
20479                 ndr_print_WERROR(ndr, "result", r->out.result);
20480                 ndr->depth--;
20481         }
20482         ndr->depth--;
20483 }
20484
20485 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20486 {
20487         if (flags & NDR_IN) {
20488                 if (r->in.handle == NULL) {
20489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20490                 }
20491                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
20493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
20494                 if (r->in.options) {
20495                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20496                 }
20497         }
20498         if (flags & NDR_OUT) {
20499                 if (r->out.info == NULL) {
20500                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20501                 }
20502                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
20503                 if (*r->out.info) {
20504                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20505                 }
20506                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20507         }
20508         return NDR_ERR_SUCCESS;
20509 }
20510
20511 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
20512 {
20513         uint32_t _ptr_options;
20514         uint32_t _ptr_info;
20515         TALLOC_CTX *_mem_save_handle_0;
20516         TALLOC_CTX *_mem_save_options_0;
20517         TALLOC_CTX *_mem_save_info_0;
20518         TALLOC_CTX *_mem_save_info_1;
20519         if (flags & NDR_IN) {
20520                 ZERO_STRUCT(r->out);
20521
20522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20523                         NDR_PULL_ALLOC(ndr, r->in.handle);
20524                 }
20525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
20530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
20531                 if (_ptr_options) {
20532                         NDR_PULL_ALLOC(ndr, r->in.options);
20533                 } else {
20534                         r->in.options = NULL;
20535                 }
20536                 if (r->in.options) {
20537                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20538                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
20539                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
20541                 }
20542                 NDR_PULL_ALLOC(ndr, r->out.info);
20543                 ZERO_STRUCTP(r->out.info);
20544         }
20545         if (flags & NDR_OUT) {
20546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20547                         NDR_PULL_ALLOC(ndr, r->out.info);
20548                 }
20549                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20550                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
20551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20552                 if (_ptr_info) {
20553                         NDR_PULL_ALLOC(ndr, *r->out.info);
20554                 } else {
20555                         *r->out.info = NULL;
20556                 }
20557                 if (*r->out.info) {
20558                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
20559                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
20560                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
20562                 }
20563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
20564                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20565         }
20566         return NDR_ERR_SUCCESS;
20567 }
20568
20569 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20570 {
20571         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
20572         ndr->depth++;
20573         if (flags & NDR_SET_VALUES) {
20574                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20575         }
20576         if (flags & NDR_IN) {
20577                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
20578                 ndr->depth++;
20579                 ndr_print_ptr(ndr, "handle", r->in.handle);
20580                 ndr->depth++;
20581                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20582                 ndr->depth--;
20583                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
20584                 ndr_print_ptr(ndr, "options", r->in.options);
20585                 ndr->depth++;
20586                 if (r->in.options) {
20587                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
20588                 }
20589                 ndr->depth--;
20590                 ndr->depth--;
20591         }
20592         if (flags & NDR_OUT) {
20593                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
20594                 ndr->depth++;
20595                 ndr_print_ptr(ndr, "info", r->out.info);
20596                 ndr->depth++;
20597                 ndr_print_ptr(ndr, "info", *r->out.info);
20598                 ndr->depth++;
20599                 if (*r->out.info) {
20600                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
20601                 }
20602                 ndr->depth--;
20603                 ndr->depth--;
20604                 ndr_print_WERROR(ndr, "result", r->out.result);
20605                 ndr->depth--;
20606         }
20607         ndr->depth--;
20608 }
20609
20610 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
20611 {
20612         if (flags & NDR_IN) {
20613         }
20614         if (flags & NDR_OUT) {
20615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20616         }
20617         return NDR_ERR_SUCCESS;
20618 }
20619
20620 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
20621 {
20622         if (flags & NDR_IN) {
20623         }
20624         if (flags & NDR_OUT) {
20625                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20626         }
20627         return NDR_ERR_SUCCESS;
20628 }
20629
20630 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
20631 {
20632         ndr_print_struct(ndr, name, "spoolss_44");
20633         ndr->depth++;
20634         if (flags & NDR_SET_VALUES) {
20635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20636         }
20637         if (flags & NDR_IN) {
20638                 ndr_print_struct(ndr, "in", "spoolss_44");
20639                 ndr->depth++;
20640                 ndr->depth--;
20641         }
20642         if (flags & NDR_OUT) {
20643                 ndr_print_struct(ndr, "out", "spoolss_44");
20644                 ndr->depth++;
20645                 ndr_print_WERROR(ndr, "result", r->out.result);
20646                 ndr->depth--;
20647         }
20648         ndr->depth--;
20649 }
20650
20651 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
20652 {
20653         if (flags & NDR_IN) {
20654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20655                 if (r->in.printername) {
20656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20659                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20660                 }
20661                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20662                 if (r->in.datatype) {
20663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20666                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20667                 }
20668                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
20670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20671                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
20672                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
20673         }
20674         if (flags & NDR_OUT) {
20675                 if (r->out.handle == NULL) {
20676                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20677                 }
20678                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20679                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20680         }
20681         return NDR_ERR_SUCCESS;
20682 }
20683
20684 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
20685 {
20686         uint32_t _ptr_printername;
20687         uint32_t _ptr_datatype;
20688         TALLOC_CTX *_mem_save_printername_0;
20689         TALLOC_CTX *_mem_save_datatype_0;
20690         TALLOC_CTX *_mem_save_handle_0;
20691         if (flags & NDR_IN) {
20692                 ZERO_STRUCT(r->out);
20693
20694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20695                 if (_ptr_printername) {
20696                         NDR_PULL_ALLOC(ndr, r->in.printername);
20697                 } else {
20698                         r->in.printername = NULL;
20699                 }
20700                 if (r->in.printername) {
20701                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20702                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20703                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20704                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20705                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20706                                 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));
20707                         }
20708                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20709                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20710                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20711                 }
20712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20713                 if (_ptr_datatype) {
20714                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20715                 } else {
20716                         r->in.datatype = NULL;
20717                 }
20718                 if (r->in.datatype) {
20719                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20720                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20722                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20723                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20724                                 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));
20725                         }
20726                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20727                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20729                 }
20730                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
20732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20733                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
20734                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
20735                 NDR_PULL_ALLOC(ndr, r->out.handle);
20736                 ZERO_STRUCTP(r->out.handle);
20737         }
20738         if (flags & NDR_OUT) {
20739                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20740                         NDR_PULL_ALLOC(ndr, r->out.handle);
20741                 }
20742                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20743                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20744                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20745                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20746                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20747         }
20748         return NDR_ERR_SUCCESS;
20749 }
20750
20751 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
20752 {
20753         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
20754         ndr->depth++;
20755         if (flags & NDR_SET_VALUES) {
20756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20757         }
20758         if (flags & NDR_IN) {
20759                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
20760                 ndr->depth++;
20761                 ndr_print_ptr(ndr, "printername", r->in.printername);
20762                 ndr->depth++;
20763                 if (r->in.printername) {
20764                         ndr_print_string(ndr, "printername", r->in.printername);
20765                 }
20766                 ndr->depth--;
20767                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20768                 ndr->depth++;
20769                 if (r->in.datatype) {
20770                         ndr_print_string(ndr, "datatype", r->in.datatype);
20771                 }
20772                 ndr->depth--;
20773                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20774                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
20775                 ndr_print_uint32(ndr, "level", r->in.level);
20776                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
20777                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
20778                 ndr->depth--;
20779         }
20780         if (flags & NDR_OUT) {
20781                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
20782                 ndr->depth++;
20783                 ndr_print_ptr(ndr, "handle", r->out.handle);
20784                 ndr->depth++;
20785                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20786                 ndr->depth--;
20787                 ndr_print_WERROR(ndr, "result", r->out.result);
20788                 ndr->depth--;
20789         }
20790         ndr->depth--;
20791 }
20792
20793 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
20794 {
20795         if (flags & NDR_IN) {
20796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20797                 if (r->in.server) {
20798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20801                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20802                 }
20803                 if (r->in.info_ctr == NULL) {
20804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20805                 }
20806                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20807                 if (r->in.devmode_ctr == NULL) {
20808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20809                 }
20810                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20811                 if (r->in.secdesc_ctr == NULL) {
20812                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20813                 }
20814                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20815                 if (r->in.userlevel_ctr == NULL) {
20816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20817                 }
20818                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
20819         }
20820         if (flags & NDR_OUT) {
20821                 if (r->out.handle == NULL) {
20822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20823                 }
20824                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20825                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20826         }
20827         return NDR_ERR_SUCCESS;
20828 }
20829
20830 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
20831 {
20832         uint32_t _ptr_server;
20833         TALLOC_CTX *_mem_save_server_0;
20834         TALLOC_CTX *_mem_save_info_ctr_0;
20835         TALLOC_CTX *_mem_save_devmode_ctr_0;
20836         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20837         TALLOC_CTX *_mem_save_userlevel_ctr_0;
20838         TALLOC_CTX *_mem_save_handle_0;
20839         if (flags & NDR_IN) {
20840                 ZERO_STRUCT(r->out);
20841
20842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20843                 if (_ptr_server) {
20844                         NDR_PULL_ALLOC(ndr, r->in.server);
20845                 } else {
20846                         r->in.server = NULL;
20847                 }
20848                 if (r->in.server) {
20849                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20853                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20854                                 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));
20855                         }
20856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20857                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20859                 }
20860                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20861                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20862                 }
20863                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20864                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20865                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20866                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20867                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20868                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20869                 }
20870                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20871                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20872                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20873                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20875                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20876                 }
20877                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20879                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20882                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
20883                 }
20884                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20885                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
20886                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
20887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20888                 NDR_PULL_ALLOC(ndr, r->out.handle);
20889                 ZERO_STRUCTP(r->out.handle);
20890         }
20891         if (flags & NDR_OUT) {
20892                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20893                         NDR_PULL_ALLOC(ndr, r->out.handle);
20894                 }
20895                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20896                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20897                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20899                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20900         }
20901         return NDR_ERR_SUCCESS;
20902 }
20903
20904 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
20905 {
20906         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
20907         ndr->depth++;
20908         if (flags & NDR_SET_VALUES) {
20909                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20910         }
20911         if (flags & NDR_IN) {
20912                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
20913                 ndr->depth++;
20914                 ndr_print_ptr(ndr, "server", r->in.server);
20915                 ndr->depth++;
20916                 if (r->in.server) {
20917                         ndr_print_string(ndr, "server", r->in.server);
20918                 }
20919                 ndr->depth--;
20920                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20921                 ndr->depth++;
20922                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20923                 ndr->depth--;
20924                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20925                 ndr->depth++;
20926                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20927                 ndr->depth--;
20928                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20929                 ndr->depth++;
20930                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20931                 ndr->depth--;
20932                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
20933                 ndr->depth++;
20934                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
20935                 ndr->depth--;
20936                 ndr->depth--;
20937         }
20938         if (flags & NDR_OUT) {
20939                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
20940                 ndr->depth++;
20941                 ndr_print_ptr(ndr, "handle", r->out.handle);
20942                 ndr->depth++;
20943                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20944                 ndr->depth--;
20945                 ndr_print_WERROR(ndr, "result", r->out.result);
20946                 ndr->depth--;
20947         }
20948         ndr->depth--;
20949 }
20950
20951 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
20952 {
20953         if (flags & NDR_IN) {
20954         }
20955         if (flags & NDR_OUT) {
20956                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20957         }
20958         return NDR_ERR_SUCCESS;
20959 }
20960
20961 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
20962 {
20963         if (flags & NDR_IN) {
20964         }
20965         if (flags & NDR_OUT) {
20966                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20967         }
20968         return NDR_ERR_SUCCESS;
20969 }
20970
20971 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
20972 {
20973         ndr_print_struct(ndr, name, "spoolss_47");
20974         ndr->depth++;
20975         if (flags & NDR_SET_VALUES) {
20976                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20977         }
20978         if (flags & NDR_IN) {
20979                 ndr_print_struct(ndr, "in", "spoolss_47");
20980                 ndr->depth++;
20981                 ndr->depth--;
20982         }
20983         if (flags & NDR_OUT) {
20984                 ndr_print_struct(ndr, "out", "spoolss_47");
20985                 ndr->depth++;
20986                 ndr_print_WERROR(ndr, "result", r->out.result);
20987                 ndr->depth--;
20988         }
20989         ndr->depth--;
20990 }
20991
20992 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
20993 {
20994         if (flags & NDR_IN) {
20995                 if (r->in.handle == NULL) {
20996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20997                 }
20998                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
21000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
21001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
21002         }
21003         if (flags & NDR_OUT) {
21004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
21005                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
21006                 if (r->out.value_needed == NULL) {
21007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21008                 }
21009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
21010                 if (r->out.printerdata_type == NULL) {
21011                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21012                 }
21013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
21014                 if (r->out.buffer == NULL) {
21015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21016                 }
21017                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
21018                 if (r->out.data_needed == NULL) {
21019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21020                 }
21021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
21022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21023         }
21024         return NDR_ERR_SUCCESS;
21025 }
21026
21027 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
21028 {
21029         TALLOC_CTX *_mem_save_handle_0;
21030         TALLOC_CTX *_mem_save_value_needed_0;
21031         TALLOC_CTX *_mem_save_printerdata_type_0;
21032         TALLOC_CTX *_mem_save_buffer_0;
21033         TALLOC_CTX *_mem_save_data_needed_0;
21034         if (flags & NDR_IN) {
21035                 ZERO_STRUCT(r->out);
21036
21037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21038                         NDR_PULL_ALLOC(ndr, r->in.handle);
21039                 }
21040                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21041                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21042                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
21045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
21046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
21047                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
21048                 ZERO_STRUCTP(r->out.value_needed);
21049                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21050                 ZERO_STRUCTP(r->out.printerdata_type);
21051                 NDR_PULL_ALLOC(ndr, r->out.buffer);
21052                 ZERO_STRUCTP(r->out.buffer);
21053                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
21054                 ZERO_STRUCTP(r->out.data_needed);
21055         }
21056         if (flags & NDR_OUT) {
21057                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
21058                 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));
21059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21060                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
21061                 }
21062                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21063                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
21064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
21065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
21066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21067                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21068                 }
21069                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21070                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
21071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
21072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
21073                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21074                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21075                 }
21076                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21077                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
21078                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
21079                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
21080                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21081                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
21082                 }
21083                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21084                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
21085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
21086                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
21087                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21088                 if (r->out.value_name) {
21089                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
21090                 }
21091         }
21092         return NDR_ERR_SUCCESS;
21093 }
21094
21095 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
21096 {
21097         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
21098         ndr->depth++;
21099         if (flags & NDR_SET_VALUES) {
21100                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21101         }
21102         if (flags & NDR_IN) {
21103                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
21104                 ndr->depth++;
21105                 ndr_print_ptr(ndr, "handle", r->in.handle);
21106                 ndr->depth++;
21107                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21108                 ndr->depth--;
21109                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
21110                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
21111                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
21112                 ndr->depth--;
21113         }
21114         if (flags & NDR_OUT) {
21115                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
21116                 ndr->depth++;
21117                 ndr_print_string(ndr, "value_name", r->out.value_name);
21118                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
21119                 ndr->depth++;
21120                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
21121                 ndr->depth--;
21122                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
21123                 ndr->depth++;
21124                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
21125                 ndr->depth--;
21126                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21127                 ndr->depth++;
21128                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
21129                 ndr->depth--;
21130                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
21131                 ndr->depth++;
21132                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
21133                 ndr->depth--;
21134                 ndr_print_WERROR(ndr, "result", r->out.result);
21135                 ndr->depth--;
21136         }
21137         ndr->depth--;
21138 }
21139
21140 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
21141 {
21142         if (flags & NDR_IN) {
21143                 if (r->in.handle == NULL) {
21144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21145                 }
21146                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21150                 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));
21151         }
21152         if (flags & NDR_OUT) {
21153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21154         }
21155         return NDR_ERR_SUCCESS;
21156 }
21157
21158 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
21159 {
21160         TALLOC_CTX *_mem_save_handle_0;
21161         if (flags & NDR_IN) {
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_array_size(ndr, &r->in.value_name));
21170                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21171                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21172                         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));
21173                 }
21174                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21175                 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));
21176         }
21177         if (flags & NDR_OUT) {
21178                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21179         }
21180         return NDR_ERR_SUCCESS;
21181 }
21182
21183 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
21184 {
21185         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
21186         ndr->depth++;
21187         if (flags & NDR_SET_VALUES) {
21188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21189         }
21190         if (flags & NDR_IN) {
21191                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
21192                 ndr->depth++;
21193                 ndr_print_ptr(ndr, "handle", r->in.handle);
21194                 ndr->depth++;
21195                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21196                 ndr->depth--;
21197                 ndr_print_string(ndr, "value_name", r->in.value_name);
21198                 ndr->depth--;
21199         }
21200         if (flags & NDR_OUT) {
21201                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
21202                 ndr->depth++;
21203                 ndr_print_WERROR(ndr, "result", r->out.result);
21204                 ndr->depth--;
21205         }
21206         ndr->depth--;
21207 }
21208
21209 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
21210 {
21211         if (flags & NDR_IN) {
21212         }
21213         if (flags & NDR_OUT) {
21214                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21215         }
21216         return NDR_ERR_SUCCESS;
21217 }
21218
21219 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
21220 {
21221         if (flags & NDR_IN) {
21222         }
21223         if (flags & NDR_OUT) {
21224                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21225         }
21226         return NDR_ERR_SUCCESS;
21227 }
21228
21229 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
21230 {
21231         ndr_print_struct(ndr, name, "spoolss_4a");
21232         ndr->depth++;
21233         if (flags & NDR_SET_VALUES) {
21234                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21235         }
21236         if (flags & NDR_IN) {
21237                 ndr_print_struct(ndr, "in", "spoolss_4a");
21238                 ndr->depth++;
21239                 ndr->depth--;
21240         }
21241         if (flags & NDR_OUT) {
21242                 ndr_print_struct(ndr, "out", "spoolss_4a");
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_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *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_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *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_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
21271 {
21272         ndr_print_struct(ndr, name, "spoolss_4b");
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_4b");
21279                 ndr->depth++;
21280                 ndr->depth--;
21281         }
21282         if (flags & NDR_OUT) {
21283                 ndr_print_struct(ndr, "out", "spoolss_4b");
21284                 ndr->depth++;
21285                 ndr_print_WERROR(ndr, "result", r->out.result);
21286                 ndr->depth--;
21287         }
21288         ndr->depth--;
21289 }
21290
21291 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
21292 {
21293         if (flags & NDR_IN) {
21294         }
21295         if (flags & NDR_OUT) {
21296                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21297         }
21298         return NDR_ERR_SUCCESS;
21299 }
21300
21301 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
21302 {
21303         if (flags & NDR_IN) {
21304         }
21305         if (flags & NDR_OUT) {
21306                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21307         }
21308         return NDR_ERR_SUCCESS;
21309 }
21310
21311 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
21312 {
21313         ndr_print_struct(ndr, name, "spoolss_4c");
21314         ndr->depth++;
21315         if (flags & NDR_SET_VALUES) {
21316                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21317         }
21318         if (flags & NDR_IN) {
21319                 ndr_print_struct(ndr, "in", "spoolss_4c");
21320                 ndr->depth++;
21321                 ndr->depth--;
21322         }
21323         if (flags & NDR_OUT) {
21324                 ndr_print_struct(ndr, "out", "spoolss_4c");
21325                 ndr->depth++;
21326                 ndr_print_WERROR(ndr, "result", r->out.result);
21327                 ndr->depth--;
21328         }
21329         ndr->depth--;
21330 }
21331
21332 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
21333 {
21334         if (flags & NDR_IN) {
21335                 if (r->in.handle == NULL) {
21336                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21337                 }
21338                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21342                 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));
21343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21346                 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));
21347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
21348                 if (r->in.buffer == NULL) {
21349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21350                 }
21351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21352                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21354         }
21355         if (flags & NDR_OUT) {
21356                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21357         }
21358         return NDR_ERR_SUCCESS;
21359 }
21360
21361 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
21362 {
21363         TALLOC_CTX *_mem_save_handle_0;
21364         if (flags & NDR_IN) {
21365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21366                         NDR_PULL_ALLOC(ndr, r->in.handle);
21367                 }
21368                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21370                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21372                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21373                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21374                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21375                         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));
21376                 }
21377                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21378                 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));
21379                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21380                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21381                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21382                         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));
21383                 }
21384                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21385                 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));
21386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
21387                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21389                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21390                 }
21391                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21393                 if (r->in.buffer) {
21394                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21395                 }
21396         }
21397         if (flags & NDR_OUT) {
21398                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21399         }
21400         return NDR_ERR_SUCCESS;
21401 }
21402
21403 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
21404 {
21405         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
21406         ndr->depth++;
21407         if (flags & NDR_SET_VALUES) {
21408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21409         }
21410         if (flags & NDR_IN) {
21411                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
21412                 ndr->depth++;
21413                 ndr_print_ptr(ndr, "handle", r->in.handle);
21414                 ndr->depth++;
21415                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21416                 ndr->depth--;
21417                 ndr_print_string(ndr, "key_name", r->in.key_name);
21418                 ndr_print_string(ndr, "value_name", r->in.value_name);
21419                 ndr_print_uint32(ndr, "type", r->in.type);
21420                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21421                 ndr->depth++;
21422                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21423                 ndr->depth--;
21424                 ndr_print_uint32(ndr, "offered", r->in.offered);
21425                 ndr->depth--;
21426         }
21427         if (flags & NDR_OUT) {
21428                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
21429                 ndr->depth++;
21430                 ndr_print_WERROR(ndr, "result", r->out.result);
21431                 ndr->depth--;
21432         }
21433         ndr->depth--;
21434 }
21435
21436 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
21437 {
21438         if (flags & NDR_IN) {
21439                 if (r->in.handle == NULL) {
21440                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21441                 }
21442                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21446                 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));
21447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21450                 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));
21451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21452         }
21453         if (flags & NDR_OUT) {
21454                 if (r->out.type == NULL) {
21455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21456                 }
21457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
21458                 if (r->out.buffer == NULL) {
21459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21460                 }
21461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21462                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21463                 if (r->out.needed == NULL) {
21464                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21465                 }
21466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21467                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21468         }
21469         return NDR_ERR_SUCCESS;
21470 }
21471
21472 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
21473 {
21474         TALLOC_CTX *_mem_save_handle_0;
21475         TALLOC_CTX *_mem_save_type_0;
21476         TALLOC_CTX *_mem_save_needed_0;
21477         if (flags & NDR_IN) {
21478                 ZERO_STRUCT(r->out);
21479
21480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21481                         NDR_PULL_ALLOC(ndr, r->in.handle);
21482                 }
21483                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21484                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21487                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21488                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21489                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21490                         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));
21491                 }
21492                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21493                 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));
21494                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21495                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21496                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21497                         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));
21498                 }
21499                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21500                 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));
21501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21502                 NDR_PULL_ALLOC(ndr, r->out.type);
21503                 ZERO_STRUCTP(r->out.type);
21504                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
21505                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
21506                 NDR_PULL_ALLOC(ndr, r->out.needed);
21507                 ZERO_STRUCTP(r->out.needed);
21508         }
21509         if (flags & NDR_OUT) {
21510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21511                         NDR_PULL_ALLOC(ndr, r->out.type);
21512                 }
21513                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21514                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
21516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21517                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21518                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21519                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21520                 }
21521                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21523                         NDR_PULL_ALLOC(ndr, r->out.needed);
21524                 }
21525                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21526                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21529                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21530                 if (r->out.buffer) {
21531                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21532                 }
21533         }
21534         return NDR_ERR_SUCCESS;
21535 }
21536
21537 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
21538 {
21539         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
21540         ndr->depth++;
21541         if (flags & NDR_SET_VALUES) {
21542                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21543         }
21544         if (flags & NDR_IN) {
21545                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
21546                 ndr->depth++;
21547                 ndr_print_ptr(ndr, "handle", r->in.handle);
21548                 ndr->depth++;
21549                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21550                 ndr->depth--;
21551                 ndr_print_string(ndr, "key_name", r->in.key_name);
21552                 ndr_print_string(ndr, "value_name", r->in.value_name);
21553                 ndr_print_uint32(ndr, "offered", r->in.offered);
21554                 ndr->depth--;
21555         }
21556         if (flags & NDR_OUT) {
21557                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
21558                 ndr->depth++;
21559                 ndr_print_ptr(ndr, "type", r->out.type);
21560                 ndr->depth++;
21561                 ndr_print_uint32(ndr, "type", *r->out.type);
21562                 ndr->depth--;
21563                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21564                 ndr->depth++;
21565                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21566                 ndr->depth--;
21567                 ndr_print_ptr(ndr, "needed", r->out.needed);
21568                 ndr->depth++;
21569                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21570                 ndr->depth--;
21571                 ndr_print_WERROR(ndr, "result", r->out.result);
21572                 ndr->depth--;
21573         }
21574         ndr->depth--;
21575 }
21576
21577 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
21578 {
21579         if (flags & NDR_IN) {
21580                 if (r->in.handle == NULL) {
21581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21582                 }
21583                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21587                 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));
21588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21589         }
21590         if (flags & NDR_OUT) {
21591                 if (r->out.buffer == NULL) {
21592                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21593                 }
21594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21595                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21596                 if (r->out.needed == NULL) {
21597                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21598                 }
21599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21600                 if (r->out.count == NULL) {
21601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21602                 }
21603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21604                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21605         }
21606         return NDR_ERR_SUCCESS;
21607 }
21608
21609 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
21610 {
21611         TALLOC_CTX *_mem_save_handle_0;
21612         TALLOC_CTX *_mem_save_needed_0;
21613         TALLOC_CTX *_mem_save_count_0;
21614         if (flags & NDR_IN) {
21615                 ZERO_STRUCT(r->out);
21616
21617                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21618                         NDR_PULL_ALLOC(ndr, r->in.handle);
21619                 }
21620                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21621                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21622                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21624                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21625                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21626                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21627                         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));
21628                 }
21629                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21630                 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));
21631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21632                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
21633                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
21634                 NDR_PULL_ALLOC(ndr, r->out.needed);
21635                 ZERO_STRUCTP(r->out.needed);
21636                 NDR_PULL_ALLOC(ndr, r->out.count);
21637                 ZERO_STRUCTP(r->out.count);
21638         }
21639         if (flags & NDR_OUT) {
21640                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21641                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21642                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21643                 }
21644                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21646                         NDR_PULL_ALLOC(ndr, r->out.needed);
21647                 }
21648                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21649                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21651                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21652                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21653                         NDR_PULL_ALLOC(ndr, r->out.count);
21654                 }
21655                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21656                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21660                 if (r->out.buffer) {
21661                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21662                 }
21663         }
21664         return NDR_ERR_SUCCESS;
21665 }
21666
21667 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
21668 {
21669         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
21670         ndr->depth++;
21671         if (flags & NDR_SET_VALUES) {
21672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21673         }
21674         if (flags & NDR_IN) {
21675                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
21676                 ndr->depth++;
21677                 ndr_print_ptr(ndr, "handle", r->in.handle);
21678                 ndr->depth++;
21679                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21680                 ndr->depth--;
21681                 ndr_print_string(ndr, "key_name", r->in.key_name);
21682                 ndr_print_uint32(ndr, "offered", r->in.offered);
21683                 ndr->depth--;
21684         }
21685         if (flags & NDR_OUT) {
21686                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
21687                 ndr->depth++;
21688                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21689                 ndr->depth++;
21690                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21691                 ndr->depth--;
21692                 ndr_print_ptr(ndr, "needed", r->out.needed);
21693                 ndr->depth++;
21694                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21695                 ndr->depth--;
21696                 ndr_print_ptr(ndr, "count", r->out.count);
21697                 ndr->depth++;
21698                 ndr_print_uint32(ndr, "count", *r->out.count);
21699                 ndr->depth--;
21700                 ndr_print_WERROR(ndr, "result", r->out.result);
21701                 ndr->depth--;
21702         }
21703         ndr->depth--;
21704 }
21705
21706 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
21707 {
21708         uint32_t cntr_key_buffer_1;
21709         if (flags & NDR_IN) {
21710                 if (r->in.handle == NULL) {
21711                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21712                 }
21713                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21717                 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));
21718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
21719         }
21720         if (flags & NDR_OUT) {
21721                 if (r->out.key_buffer == NULL) {
21722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21723                 }
21724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
21725                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
21726                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
21727                 }
21728                 if (r->out.needed == NULL) {
21729                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21730                 }
21731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21732                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21733         }
21734         return NDR_ERR_SUCCESS;
21735 }
21736
21737 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
21738 {
21739         uint32_t cntr_key_buffer_1;
21740         TALLOC_CTX *_mem_save_handle_0;
21741         TALLOC_CTX *_mem_save_key_buffer_1;
21742         TALLOC_CTX *_mem_save_needed_0;
21743         if (flags & NDR_IN) {
21744                 ZERO_STRUCT(r->out);
21745
21746                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21747                         NDR_PULL_ALLOC(ndr, r->in.handle);
21748                 }
21749                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21750                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21751                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21752                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21753                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21754                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21755                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21756                         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));
21757                 }
21758                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21759                 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));
21760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
21761                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
21762                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
21763                 NDR_PULL_ALLOC(ndr, r->out.needed);
21764                 ZERO_STRUCTP(r->out.needed);
21765         }
21766         if (flags & NDR_OUT) {
21767                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
21768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21769                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
21770                 }
21771                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
21772                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
21773                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
21774                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
21775                 }
21776                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
21777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21778                         NDR_PULL_ALLOC(ndr, r->out.needed);
21779                 }
21780                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21781                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21784                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21785                 if (r->out.key_buffer) {
21786                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
21787                 }
21788         }
21789         return NDR_ERR_SUCCESS;
21790 }
21791
21792 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
21793 {
21794         uint32_t cntr_key_buffer_1;
21795         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
21796         ndr->depth++;
21797         if (flags & NDR_SET_VALUES) {
21798                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21799         }
21800         if (flags & NDR_IN) {
21801                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
21802                 ndr->depth++;
21803                 ndr_print_ptr(ndr, "handle", r->in.handle);
21804                 ndr->depth++;
21805                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21806                 ndr->depth--;
21807                 ndr_print_string(ndr, "key_name", r->in.key_name);
21808                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
21809                 ndr->depth--;
21810         }
21811         if (flags & NDR_OUT) {
21812                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
21813                 ndr->depth++;
21814                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
21815                 ndr->depth++;
21816                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
21817                 ndr->depth++;
21818                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
21819                         char *idx_1=NULL;
21820                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
21821                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
21822                                 free(idx_1);
21823                         }
21824                 }
21825                 ndr->depth--;
21826                 ndr->depth--;
21827                 ndr_print_ptr(ndr, "needed", r->out.needed);
21828                 ndr->depth++;
21829                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21830                 ndr->depth--;
21831                 ndr_print_WERROR(ndr, "result", r->out.result);
21832                 ndr->depth--;
21833         }
21834         ndr->depth--;
21835 }
21836
21837 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
21838 {
21839         if (flags & NDR_IN) {
21840                 if (r->in.handle == NULL) {
21841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21842                 }
21843                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21847                 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));
21848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21851                 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));
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_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
21860 {
21861         TALLOC_CTX *_mem_save_handle_0;
21862         if (flags & NDR_IN) {
21863                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21864                         NDR_PULL_ALLOC(ndr, r->in.handle);
21865                 }
21866                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21867                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21868                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21870                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21871                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21872                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21873                         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));
21874                 }
21875                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21876                 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));
21877                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21878                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21879                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21880                         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));
21881                 }
21882                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21883                 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));
21884         }
21885         if (flags & NDR_OUT) {
21886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21887         }
21888         return NDR_ERR_SUCCESS;
21889 }
21890
21891 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
21892 {
21893         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
21894         ndr->depth++;
21895         if (flags & NDR_SET_VALUES) {
21896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21897         }
21898         if (flags & NDR_IN) {
21899                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
21900                 ndr->depth++;
21901                 ndr_print_ptr(ndr, "handle", r->in.handle);
21902                 ndr->depth++;
21903                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21904                 ndr->depth--;
21905                 ndr_print_string(ndr, "key_name", r->in.key_name);
21906                 ndr_print_string(ndr, "value_name", r->in.value_name);
21907                 ndr->depth--;
21908         }
21909         if (flags & NDR_OUT) {
21910                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
21911                 ndr->depth++;
21912                 ndr_print_WERROR(ndr, "result", r->out.result);
21913                 ndr->depth--;
21914         }
21915         ndr->depth--;
21916 }
21917
21918 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
21919 {
21920         if (flags & NDR_IN) {
21921                 if (r->in.handle == NULL) {
21922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21923                 }
21924                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21928                 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));
21929         }
21930         if (flags & NDR_OUT) {
21931                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21932         }
21933         return NDR_ERR_SUCCESS;
21934 }
21935
21936 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
21937 {
21938         TALLOC_CTX *_mem_save_handle_0;
21939         if (flags & NDR_IN) {
21940                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21941                         NDR_PULL_ALLOC(ndr, r->in.handle);
21942                 }
21943                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21944                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21945                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21947                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21948                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21949                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21950                         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));
21951                 }
21952                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21953                 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));
21954         }
21955         if (flags & NDR_OUT) {
21956                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21957         }
21958         return NDR_ERR_SUCCESS;
21959 }
21960
21961 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
21962 {
21963         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
21964         ndr->depth++;
21965         if (flags & NDR_SET_VALUES) {
21966                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21967         }
21968         if (flags & NDR_IN) {
21969                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
21970                 ndr->depth++;
21971                 ndr_print_ptr(ndr, "handle", r->in.handle);
21972                 ndr->depth++;
21973                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21974                 ndr->depth--;
21975                 ndr_print_string(ndr, "key_name", r->in.key_name);
21976                 ndr->depth--;
21977         }
21978         if (flags & NDR_OUT) {
21979                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
21980                 ndr->depth++;
21981                 ndr_print_WERROR(ndr, "result", r->out.result);
21982                 ndr->depth--;
21983         }
21984         ndr->depth--;
21985 }
21986
21987 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
21988 {
21989         if (flags & NDR_IN) {
21990         }
21991         if (flags & NDR_OUT) {
21992                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21993         }
21994         return NDR_ERR_SUCCESS;
21995 }
21996
21997 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
21998 {
21999         if (flags & NDR_IN) {
22000         }
22001         if (flags & NDR_OUT) {
22002                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22003         }
22004         return NDR_ERR_SUCCESS;
22005 }
22006
22007 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
22008 {
22009         ndr_print_struct(ndr, name, "spoolss_53");
22010         ndr->depth++;
22011         if (flags & NDR_SET_VALUES) {
22012                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22013         }
22014         if (flags & NDR_IN) {
22015                 ndr_print_struct(ndr, "in", "spoolss_53");
22016                 ndr->depth++;
22017                 ndr->depth--;
22018         }
22019         if (flags & NDR_OUT) {
22020                 ndr_print_struct(ndr, "out", "spoolss_53");
22021                 ndr->depth++;
22022                 ndr_print_WERROR(ndr, "result", r->out.result);
22023                 ndr->depth--;
22024         }
22025         ndr->depth--;
22026 }
22027
22028 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22029 {
22030         if (flags & NDR_IN) {
22031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22032                 if (r->in.server) {
22033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22036                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22037                 }
22038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22041                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22045                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22046                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
22047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
22048         }
22049         if (flags & NDR_OUT) {
22050                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22051         }
22052         return NDR_ERR_SUCCESS;
22053 }
22054
22055 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
22056 {
22057         uint32_t _ptr_server;
22058         TALLOC_CTX *_mem_save_server_0;
22059         if (flags & NDR_IN) {
22060                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22061                 if (_ptr_server) {
22062                         NDR_PULL_ALLOC(ndr, r->in.server);
22063                 } else {
22064                         r->in.server = NULL;
22065                 }
22066                 if (r->in.server) {
22067                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22068                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22069                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22070                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22071                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22072                                 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));
22073                         }
22074                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22075                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22077                 }
22078                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22079                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22080                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22081                         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));
22082                 }
22083                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22084                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22085                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22086                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22087                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22088                         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));
22089                 }
22090                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22091                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22092                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
22093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
22094         }
22095         if (flags & NDR_OUT) {
22096                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22097         }
22098         return NDR_ERR_SUCCESS;
22099 }
22100
22101 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22102 {
22103         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
22104         ndr->depth++;
22105         if (flags & NDR_SET_VALUES) {
22106                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22107         }
22108         if (flags & NDR_IN) {
22109                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
22110                 ndr->depth++;
22111                 ndr_print_ptr(ndr, "server", r->in.server);
22112                 ndr->depth++;
22113                 if (r->in.server) {
22114                         ndr_print_string(ndr, "server", r->in.server);
22115                 }
22116                 ndr->depth--;
22117                 ndr_print_string(ndr, "architecture", r->in.architecture);
22118                 ndr_print_string(ndr, "driver", r->in.driver);
22119                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
22120                 ndr_print_uint32(ndr, "version", r->in.version);
22121                 ndr->depth--;
22122         }
22123         if (flags & NDR_OUT) {
22124                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
22125                 ndr->depth++;
22126                 ndr_print_WERROR(ndr, "result", r->out.result);
22127                 ndr->depth--;
22128         }
22129         ndr->depth--;
22130 }
22131
22132 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
22133 {
22134         if (flags & NDR_IN) {
22135         }
22136         if (flags & NDR_OUT) {
22137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22138         }
22139         return NDR_ERR_SUCCESS;
22140 }
22141
22142 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
22143 {
22144         if (flags & NDR_IN) {
22145         }
22146         if (flags & NDR_OUT) {
22147                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22148         }
22149         return NDR_ERR_SUCCESS;
22150 }
22151
22152 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
22153 {
22154         ndr_print_struct(ndr, name, "spoolss_55");
22155         ndr->depth++;
22156         if (flags & NDR_SET_VALUES) {
22157                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22158         }
22159         if (flags & NDR_IN) {
22160                 ndr_print_struct(ndr, "in", "spoolss_55");
22161                 ndr->depth++;
22162                 ndr->depth--;
22163         }
22164         if (flags & NDR_OUT) {
22165                 ndr_print_struct(ndr, "out", "spoolss_55");
22166                 ndr->depth++;
22167                 ndr_print_WERROR(ndr, "result", r->out.result);
22168                 ndr->depth--;
22169         }
22170         ndr->depth--;
22171 }
22172
22173 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
22174 {
22175         if (flags & NDR_IN) {
22176         }
22177         if (flags & NDR_OUT) {
22178                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22179         }
22180         return NDR_ERR_SUCCESS;
22181 }
22182
22183 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
22184 {
22185         if (flags & NDR_IN) {
22186         }
22187         if (flags & NDR_OUT) {
22188                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22189         }
22190         return NDR_ERR_SUCCESS;
22191 }
22192
22193 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
22194 {
22195         ndr_print_struct(ndr, name, "spoolss_56");
22196         ndr->depth++;
22197         if (flags & NDR_SET_VALUES) {
22198                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22199         }
22200         if (flags & NDR_IN) {
22201                 ndr_print_struct(ndr, "in", "spoolss_56");
22202                 ndr->depth++;
22203                 ndr->depth--;
22204         }
22205         if (flags & NDR_OUT) {
22206                 ndr_print_struct(ndr, "out", "spoolss_56");
22207                 ndr->depth++;
22208                 ndr_print_WERROR(ndr, "result", r->out.result);
22209                 ndr->depth--;
22210         }
22211         ndr->depth--;
22212 }
22213
22214 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
22215 {
22216         if (flags & NDR_IN) {
22217         }
22218         if (flags & NDR_OUT) {
22219                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22220         }
22221         return NDR_ERR_SUCCESS;
22222 }
22223
22224 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
22225 {
22226         if (flags & NDR_IN) {
22227         }
22228         if (flags & NDR_OUT) {
22229                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22230         }
22231         return NDR_ERR_SUCCESS;
22232 }
22233
22234 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
22235 {
22236         ndr_print_struct(ndr, name, "spoolss_57");
22237         ndr->depth++;
22238         if (flags & NDR_SET_VALUES) {
22239                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22240         }
22241         if (flags & NDR_IN) {
22242                 ndr_print_struct(ndr, "in", "spoolss_57");
22243                 ndr->depth++;
22244                 ndr->depth--;
22245         }
22246         if (flags & NDR_OUT) {
22247                 ndr_print_struct(ndr, "out", "spoolss_57");
22248                 ndr->depth++;
22249                 ndr_print_WERROR(ndr, "result", r->out.result);
22250                 ndr->depth--;
22251         }
22252         ndr->depth--;
22253 }
22254
22255 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
22256 {
22257         if (flags & NDR_IN) {
22258                 if (r->in.handle == NULL) {
22259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22260                 }
22261                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22265                 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));
22266                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
22267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
22268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22269                 if (r->in.status_code == NULL) {
22270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22271                 }
22272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
22273         }
22274         if (flags & NDR_OUT) {
22275                 if (r->out.out_data == NULL) {
22276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22277                 }
22278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22279                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
22280                 if (r->out.needed == NULL) {
22281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22282                 }
22283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22284                 if (r->out.status_code == NULL) {
22285                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22286                 }
22287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
22288                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22289         }
22290         return NDR_ERR_SUCCESS;
22291 }
22292
22293 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
22294 {
22295         TALLOC_CTX *_mem_save_handle_0;
22296         TALLOC_CTX *_mem_save_needed_0;
22297         TALLOC_CTX *_mem_save_status_code_0;
22298         if (flags & NDR_IN) {
22299                 ZERO_STRUCT(r->out);
22300
22301                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22302                         NDR_PULL_ALLOC(ndr, r->in.handle);
22303                 }
22304                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22305                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22306                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22308                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
22309                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
22310                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
22311                         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));
22312                 }
22313                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
22314                 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));
22315                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
22316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
22317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
22318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22319                         NDR_PULL_ALLOC(ndr, r->in.status_code);
22320                 }
22321                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
22323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
22324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22325                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
22326                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
22327                 NDR_PULL_ALLOC(ndr, r->out.needed);
22328                 ZERO_STRUCTP(r->out.needed);
22329                 NDR_PULL_ALLOC(ndr, r->out.status_code);
22330                 *r->out.status_code = *r->in.status_code;
22331         }
22332         if (flags & NDR_OUT) {
22333                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
22334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22335                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
22336                 }
22337                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
22338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22339                         NDR_PULL_ALLOC(ndr, r->out.needed);
22340                 }
22341                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22342                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22346                         NDR_PULL_ALLOC(ndr, r->out.status_code);
22347                 }
22348                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22349                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
22350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
22351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22352                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22353                 if (r->out.out_data) {
22354                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
22355                 }
22356         }
22357         return NDR_ERR_SUCCESS;
22358 }
22359
22360 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
22361 {
22362         ndr_print_struct(ndr, name, "spoolss_XcvData");
22363         ndr->depth++;
22364         if (flags & NDR_SET_VALUES) {
22365                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22366         }
22367         if (flags & NDR_IN) {
22368                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
22369                 ndr->depth++;
22370                 ndr_print_ptr(ndr, "handle", r->in.handle);
22371                 ndr->depth++;
22372                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22373                 ndr->depth--;
22374                 ndr_print_string(ndr, "function_name", r->in.function_name);
22375                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
22376                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
22377                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
22378                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
22379                 ndr->depth++;
22380                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
22381                 ndr->depth--;
22382                 ndr->depth--;
22383         }
22384         if (flags & NDR_OUT) {
22385                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
22386                 ndr->depth++;
22387                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
22388                 ndr->depth++;
22389                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
22390                 ndr->depth--;
22391                 ndr_print_ptr(ndr, "needed", r->out.needed);
22392                 ndr->depth++;
22393                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22394                 ndr->depth--;
22395                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
22396                 ndr->depth++;
22397                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
22398                 ndr->depth--;
22399                 ndr_print_WERROR(ndr, "result", r->out.result);
22400                 ndr->depth--;
22401         }
22402         ndr->depth--;
22403 }
22404
22405 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
22406 {
22407         if (flags & NDR_IN) {
22408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22409                 if (r->in.servername) {
22410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22413                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22414                 }
22415                 if (r->in.info_ctr == NULL) {
22416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22417                 }
22418                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22419                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
22420         }
22421         if (flags & NDR_OUT) {
22422                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22423         }
22424         return NDR_ERR_SUCCESS;
22425 }
22426
22427 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
22428 {
22429         uint32_t _ptr_servername;
22430         TALLOC_CTX *_mem_save_servername_0;
22431         TALLOC_CTX *_mem_save_info_ctr_0;
22432         if (flags & NDR_IN) {
22433                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22434                 if (_ptr_servername) {
22435                         NDR_PULL_ALLOC(ndr, r->in.servername);
22436                 } else {
22437                         r->in.servername = NULL;
22438                 }
22439                 if (r->in.servername) {
22440                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22441                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22442                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22443                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22444                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22445                                 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));
22446                         }
22447                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22448                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22450                 }
22451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22452                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
22453                 }
22454                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
22455                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
22456                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
22458                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
22459         }
22460         if (flags & NDR_OUT) {
22461                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22462         }
22463         return NDR_ERR_SUCCESS;
22464 }
22465
22466 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
22467 {
22468         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
22469         ndr->depth++;
22470         if (flags & NDR_SET_VALUES) {
22471                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22472         }
22473         if (flags & NDR_IN) {
22474                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
22475                 ndr->depth++;
22476                 ndr_print_ptr(ndr, "servername", r->in.servername);
22477                 ndr->depth++;
22478                 if (r->in.servername) {
22479                         ndr_print_string(ndr, "servername", r->in.servername);
22480                 }
22481                 ndr->depth--;
22482                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
22483                 ndr->depth++;
22484                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
22485                 ndr->depth--;
22486                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
22487                 ndr->depth--;
22488         }
22489         if (flags & NDR_OUT) {
22490                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
22491                 ndr->depth++;
22492                 ndr_print_WERROR(ndr, "result", r->out.result);
22493                 ndr->depth--;
22494         }
22495         ndr->depth--;
22496 }
22497
22498 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
22499 {
22500         if (flags & NDR_IN) {
22501         }
22502         if (flags & NDR_OUT) {
22503                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22504         }
22505         return NDR_ERR_SUCCESS;
22506 }
22507
22508 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
22509 {
22510         if (flags & NDR_IN) {
22511         }
22512         if (flags & NDR_OUT) {
22513                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22514         }
22515         return NDR_ERR_SUCCESS;
22516 }
22517
22518 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
22519 {
22520         ndr_print_struct(ndr, name, "spoolss_5a");
22521         ndr->depth++;
22522         if (flags & NDR_SET_VALUES) {
22523                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22524         }
22525         if (flags & NDR_IN) {
22526                 ndr_print_struct(ndr, "in", "spoolss_5a");
22527                 ndr->depth++;
22528                 ndr->depth--;
22529         }
22530         if (flags & NDR_OUT) {
22531                 ndr_print_struct(ndr, "out", "spoolss_5a");
22532                 ndr->depth++;
22533                 ndr_print_WERROR(ndr, "result", r->out.result);
22534                 ndr->depth--;
22535         }
22536         ndr->depth--;
22537 }
22538
22539 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
22540 {
22541         if (flags & NDR_IN) {
22542         }
22543         if (flags & NDR_OUT) {
22544                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22545         }
22546         return NDR_ERR_SUCCESS;
22547 }
22548
22549 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
22550 {
22551         if (flags & NDR_IN) {
22552         }
22553         if (flags & NDR_OUT) {
22554                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22555         }
22556         return NDR_ERR_SUCCESS;
22557 }
22558
22559 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
22560 {
22561         ndr_print_struct(ndr, name, "spoolss_5b");
22562         ndr->depth++;
22563         if (flags & NDR_SET_VALUES) {
22564                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22565         }
22566         if (flags & NDR_IN) {
22567                 ndr_print_struct(ndr, "in", "spoolss_5b");
22568                 ndr->depth++;
22569                 ndr->depth--;
22570         }
22571         if (flags & NDR_OUT) {
22572                 ndr_print_struct(ndr, "out", "spoolss_5b");
22573                 ndr->depth++;
22574                 ndr_print_WERROR(ndr, "result", r->out.result);
22575                 ndr->depth--;
22576         }
22577         ndr->depth--;
22578 }
22579
22580 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
22581 {
22582         if (flags & NDR_IN) {
22583         }
22584         if (flags & NDR_OUT) {
22585                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22586         }
22587         return NDR_ERR_SUCCESS;
22588 }
22589
22590 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
22591 {
22592         if (flags & NDR_IN) {
22593         }
22594         if (flags & NDR_OUT) {
22595                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22596         }
22597         return NDR_ERR_SUCCESS;
22598 }
22599
22600 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
22601 {
22602         ndr_print_struct(ndr, name, "spoolss_5c");
22603         ndr->depth++;
22604         if (flags & NDR_SET_VALUES) {
22605                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22606         }
22607         if (flags & NDR_IN) {
22608                 ndr_print_struct(ndr, "in", "spoolss_5c");
22609                 ndr->depth++;
22610                 ndr->depth--;
22611         }
22612         if (flags & NDR_OUT) {
22613                 ndr_print_struct(ndr, "out", "spoolss_5c");
22614                 ndr->depth++;
22615                 ndr_print_WERROR(ndr, "result", r->out.result);
22616                 ndr->depth--;
22617         }
22618         ndr->depth--;
22619 }
22620
22621 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
22622 {
22623         if (flags & NDR_IN) {
22624         }
22625         if (flags & NDR_OUT) {
22626                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22627         }
22628         return NDR_ERR_SUCCESS;
22629 }
22630
22631 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
22632 {
22633         if (flags & NDR_IN) {
22634         }
22635         if (flags & NDR_OUT) {
22636                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22637         }
22638         return NDR_ERR_SUCCESS;
22639 }
22640
22641 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
22642 {
22643         ndr_print_struct(ndr, name, "spoolss_5d");
22644         ndr->depth++;
22645         if (flags & NDR_SET_VALUES) {
22646                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22647         }
22648         if (flags & NDR_IN) {
22649                 ndr_print_struct(ndr, "in", "spoolss_5d");
22650                 ndr->depth++;
22651                 ndr->depth--;
22652         }
22653         if (flags & NDR_OUT) {
22654                 ndr_print_struct(ndr, "out", "spoolss_5d");
22655                 ndr->depth++;
22656                 ndr_print_WERROR(ndr, "result", r->out.result);
22657                 ndr->depth--;
22658         }
22659         ndr->depth--;
22660 }
22661
22662 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
22663 {
22664         if (flags & NDR_IN) {
22665         }
22666         if (flags & NDR_OUT) {
22667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22668         }
22669         return NDR_ERR_SUCCESS;
22670 }
22671
22672 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
22673 {
22674         if (flags & NDR_IN) {
22675         }
22676         if (flags & NDR_OUT) {
22677                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22678         }
22679         return NDR_ERR_SUCCESS;
22680 }
22681
22682 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
22683 {
22684         ndr_print_struct(ndr, name, "spoolss_5e");
22685         ndr->depth++;
22686         if (flags & NDR_SET_VALUES) {
22687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22688         }
22689         if (flags & NDR_IN) {
22690                 ndr_print_struct(ndr, "in", "spoolss_5e");
22691                 ndr->depth++;
22692                 ndr->depth--;
22693         }
22694         if (flags & NDR_OUT) {
22695                 ndr_print_struct(ndr, "out", "spoolss_5e");
22696                 ndr->depth++;
22697                 ndr_print_WERROR(ndr, "result", r->out.result);
22698                 ndr->depth--;
22699         }
22700         ndr->depth--;
22701 }
22702
22703 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
22704 {
22705         if (flags & NDR_IN) {
22706         }
22707         if (flags & NDR_OUT) {
22708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22709         }
22710         return NDR_ERR_SUCCESS;
22711 }
22712
22713 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
22714 {
22715         if (flags & NDR_IN) {
22716         }
22717         if (flags & NDR_OUT) {
22718                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22719         }
22720         return NDR_ERR_SUCCESS;
22721 }
22722
22723 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
22724 {
22725         ndr_print_struct(ndr, name, "spoolss_5f");
22726         ndr->depth++;
22727         if (flags & NDR_SET_VALUES) {
22728                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22729         }
22730         if (flags & NDR_IN) {
22731                 ndr_print_struct(ndr, "in", "spoolss_5f");
22732                 ndr->depth++;
22733                 ndr->depth--;
22734         }
22735         if (flags & NDR_OUT) {
22736                 ndr_print_struct(ndr, "out", "spoolss_5f");
22737                 ndr->depth++;
22738                 ndr_print_WERROR(ndr, "result", r->out.result);
22739                 ndr->depth--;
22740         }
22741         ndr->depth--;
22742 }
22743
22744 static const struct ndr_interface_call spoolss_calls[] = {
22745         {
22746                 "spoolss_EnumPrinters",
22747                 sizeof(struct spoolss_EnumPrinters),
22748                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
22749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
22750                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
22751                 false,
22752         },
22753         {
22754                 "spoolss_OpenPrinter",
22755                 sizeof(struct spoolss_OpenPrinter),
22756                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
22757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
22758                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
22759                 false,
22760         },
22761         {
22762                 "spoolss_SetJob",
22763                 sizeof(struct spoolss_SetJob),
22764                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
22765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
22766                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
22767                 false,
22768         },
22769         {
22770                 "spoolss_GetJob",
22771                 sizeof(struct spoolss_GetJob),
22772                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
22773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
22774                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
22775                 false,
22776         },
22777         {
22778                 "spoolss_EnumJobs",
22779                 sizeof(struct spoolss_EnumJobs),
22780                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
22781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
22782                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
22783                 false,
22784         },
22785         {
22786                 "spoolss_AddPrinter",
22787                 sizeof(struct spoolss_AddPrinter),
22788                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
22789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
22790                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
22791                 false,
22792         },
22793         {
22794                 "spoolss_DeletePrinter",
22795                 sizeof(struct spoolss_DeletePrinter),
22796                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
22797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
22798                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
22799                 false,
22800         },
22801         {
22802                 "spoolss_SetPrinter",
22803                 sizeof(struct spoolss_SetPrinter),
22804                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
22805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
22806                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
22807                 false,
22808         },
22809         {
22810                 "spoolss_GetPrinter",
22811                 sizeof(struct spoolss_GetPrinter),
22812                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
22813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
22814                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
22815                 false,
22816         },
22817         {
22818                 "spoolss_AddPrinterDriver",
22819                 sizeof(struct spoolss_AddPrinterDriver),
22820                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
22821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
22822                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
22823                 false,
22824         },
22825         {
22826                 "spoolss_EnumPrinterDrivers",
22827                 sizeof(struct spoolss_EnumPrinterDrivers),
22828                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
22829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
22830                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
22831                 false,
22832         },
22833         {
22834                 "spoolss_GetPrinterDriver",
22835                 sizeof(struct spoolss_GetPrinterDriver),
22836                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
22837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
22838                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
22839                 false,
22840         },
22841         {
22842                 "spoolss_GetPrinterDriverDirectory",
22843                 sizeof(struct spoolss_GetPrinterDriverDirectory),
22844                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
22845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
22846                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
22847                 false,
22848         },
22849         {
22850                 "spoolss_DeletePrinterDriver",
22851                 sizeof(struct spoolss_DeletePrinterDriver),
22852                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
22853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
22854                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
22855                 false,
22856         },
22857         {
22858                 "spoolss_AddPrintProcessor",
22859                 sizeof(struct spoolss_AddPrintProcessor),
22860                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
22861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
22862                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
22863                 false,
22864         },
22865         {
22866                 "spoolss_EnumPrintProcessors",
22867                 sizeof(struct spoolss_EnumPrintProcessors),
22868                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
22869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
22870                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
22871                 false,
22872         },
22873         {
22874                 "spoolss_GetPrintProcessorDirectory",
22875                 sizeof(struct spoolss_GetPrintProcessorDirectory),
22876                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
22877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
22878                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
22879                 false,
22880         },
22881         {
22882                 "spoolss_StartDocPrinter",
22883                 sizeof(struct spoolss_StartDocPrinter),
22884                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
22885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
22886                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
22887                 false,
22888         },
22889         {
22890                 "spoolss_StartPagePrinter",
22891                 sizeof(struct spoolss_StartPagePrinter),
22892                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
22893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
22894                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
22895                 false,
22896         },
22897         {
22898                 "spoolss_WritePrinter",
22899                 sizeof(struct spoolss_WritePrinter),
22900                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
22901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
22902                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
22903                 false,
22904         },
22905         {
22906                 "spoolss_EndPagePrinter",
22907                 sizeof(struct spoolss_EndPagePrinter),
22908                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
22909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
22910                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
22911                 false,
22912         },
22913         {
22914                 "spoolss_AbortPrinter",
22915                 sizeof(struct spoolss_AbortPrinter),
22916                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
22917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
22918                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
22919                 false,
22920         },
22921         {
22922                 "spoolss_ReadPrinter",
22923                 sizeof(struct spoolss_ReadPrinter),
22924                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
22925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
22926                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
22927                 false,
22928         },
22929         {
22930                 "spoolss_EndDocPrinter",
22931                 sizeof(struct spoolss_EndDocPrinter),
22932                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
22933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
22934                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
22935                 false,
22936         },
22937         {
22938                 "spoolss_AddJob",
22939                 sizeof(struct spoolss_AddJob),
22940                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
22941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
22942                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
22943                 false,
22944         },
22945         {
22946                 "spoolss_ScheduleJob",
22947                 sizeof(struct spoolss_ScheduleJob),
22948                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
22949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
22950                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
22951                 false,
22952         },
22953         {
22954                 "spoolss_GetPrinterData",
22955                 sizeof(struct spoolss_GetPrinterData),
22956                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
22957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
22958                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
22959                 false,
22960         },
22961         {
22962                 "spoolss_SetPrinterData",
22963                 sizeof(struct spoolss_SetPrinterData),
22964                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
22965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
22966                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
22967                 false,
22968         },
22969         {
22970                 "spoolss_WaitForPrinterChange",
22971                 sizeof(struct spoolss_WaitForPrinterChange),
22972                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
22973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
22974                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
22975                 false,
22976         },
22977         {
22978                 "spoolss_ClosePrinter",
22979                 sizeof(struct spoolss_ClosePrinter),
22980                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
22981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
22982                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
22983                 false,
22984         },
22985         {
22986                 "spoolss_AddForm",
22987                 sizeof(struct spoolss_AddForm),
22988                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
22989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
22990                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
22991                 false,
22992         },
22993         {
22994                 "spoolss_DeleteForm",
22995                 sizeof(struct spoolss_DeleteForm),
22996                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
22997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
22998                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
22999                 false,
23000         },
23001         {
23002                 "spoolss_GetForm",
23003                 sizeof(struct spoolss_GetForm),
23004                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
23005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
23006                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
23007                 false,
23008         },
23009         {
23010                 "spoolss_SetForm",
23011                 sizeof(struct spoolss_SetForm),
23012                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
23013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
23014                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
23015                 false,
23016         },
23017         {
23018                 "spoolss_EnumForms",
23019                 sizeof(struct spoolss_EnumForms),
23020                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
23021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
23022                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
23023                 false,
23024         },
23025         {
23026                 "spoolss_EnumPorts",
23027                 sizeof(struct spoolss_EnumPorts),
23028                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
23029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
23030                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
23031                 false,
23032         },
23033         {
23034                 "spoolss_EnumMonitors",
23035                 sizeof(struct spoolss_EnumMonitors),
23036                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
23037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
23038                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
23039                 false,
23040         },
23041         {
23042                 "spoolss_AddPort",
23043                 sizeof(struct spoolss_AddPort),
23044                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
23045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
23046                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
23047                 false,
23048         },
23049         {
23050                 "spoolss_ConfigurePort",
23051                 sizeof(struct spoolss_ConfigurePort),
23052                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
23053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
23054                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
23055                 false,
23056         },
23057         {
23058                 "spoolss_DeletePort",
23059                 sizeof(struct spoolss_DeletePort),
23060                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
23061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
23062                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
23063                 false,
23064         },
23065         {
23066                 "spoolss_CreatePrinterIC",
23067                 sizeof(struct spoolss_CreatePrinterIC),
23068                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
23069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
23070                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
23071                 false,
23072         },
23073         {
23074                 "spoolss_PlayGDIScriptOnPrinterIC",
23075                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
23076                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
23077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
23078                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
23079                 false,
23080         },
23081         {
23082                 "spoolss_DeletePrinterIC",
23083                 sizeof(struct spoolss_DeletePrinterIC),
23084                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
23085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
23086                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
23087                 false,
23088         },
23089         {
23090                 "spoolss_AddPrinterConnection",
23091                 sizeof(struct spoolss_AddPrinterConnection),
23092                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
23093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
23094                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
23095                 false,
23096         },
23097         {
23098                 "spoolss_DeletePrinterConnection",
23099                 sizeof(struct spoolss_DeletePrinterConnection),
23100                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
23101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
23102                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
23103                 false,
23104         },
23105         {
23106                 "spoolss_PrinterMessageBox",
23107                 sizeof(struct spoolss_PrinterMessageBox),
23108                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
23109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
23110                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
23111                 false,
23112         },
23113         {
23114                 "spoolss_AddMonitor",
23115                 sizeof(struct spoolss_AddMonitor),
23116                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
23117                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
23118                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
23119                 false,
23120         },
23121         {
23122                 "spoolss_DeleteMonitor",
23123                 sizeof(struct spoolss_DeleteMonitor),
23124                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
23125                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
23126                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
23127                 false,
23128         },
23129         {
23130                 "spoolss_DeletePrintProcessor",
23131                 sizeof(struct spoolss_DeletePrintProcessor),
23132                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
23133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
23134                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
23135                 false,
23136         },
23137         {
23138                 "spoolss_AddPrintProvidor",
23139                 sizeof(struct spoolss_AddPrintProvidor),
23140                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
23141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
23142                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
23143                 false,
23144         },
23145         {
23146                 "spoolss_DeletePrintProvidor",
23147                 sizeof(struct spoolss_DeletePrintProvidor),
23148                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
23149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
23150                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
23151                 false,
23152         },
23153         {
23154                 "spoolss_EnumPrintProcDataTypes",
23155                 sizeof(struct spoolss_EnumPrintProcDataTypes),
23156                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
23157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
23158                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
23159                 false,
23160         },
23161         {
23162                 "spoolss_ResetPrinter",
23163                 sizeof(struct spoolss_ResetPrinter),
23164                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
23165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
23166                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
23167                 false,
23168         },
23169         {
23170                 "spoolss_GetPrinterDriver2",
23171                 sizeof(struct spoolss_GetPrinterDriver2),
23172                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
23173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
23174                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
23175                 false,
23176         },
23177         {
23178                 "spoolss_FindFirstPrinterChangeNotification",
23179                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
23180                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
23181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
23182                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
23183                 false,
23184         },
23185         {
23186                 "spoolss_FindNextPrinterChangeNotification",
23187                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
23188                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
23189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
23190                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
23191                 false,
23192         },
23193         {
23194                 "spoolss_FindClosePrinterNotify",
23195                 sizeof(struct spoolss_FindClosePrinterNotify),
23196                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
23197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
23198                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
23199                 false,
23200         },
23201         {
23202                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
23203                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
23204                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23206                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23207                 false,
23208         },
23209         {
23210                 "spoolss_ReplyOpenPrinter",
23211                 sizeof(struct spoolss_ReplyOpenPrinter),
23212                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
23213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
23214                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
23215                 false,
23216         },
23217         {
23218                 "spoolss_RouterReplyPrinter",
23219                 sizeof(struct spoolss_RouterReplyPrinter),
23220                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
23221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
23222                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
23223                 false,
23224         },
23225         {
23226                 "spoolss_ReplyClosePrinter",
23227                 sizeof(struct spoolss_ReplyClosePrinter),
23228                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
23229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
23230                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
23231                 false,
23232         },
23233         {
23234                 "spoolss_AddPortEx",
23235                 sizeof(struct spoolss_AddPortEx),
23236                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
23237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
23238                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
23239                 false,
23240         },
23241         {
23242                 "spoolss_RouterFindFirstPrinterChangeNotification",
23243                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
23244                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
23245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
23246                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
23247                 false,
23248         },
23249         {
23250                 "spoolss_SpoolerInit",
23251                 sizeof(struct spoolss_SpoolerInit),
23252                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
23253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
23254                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
23255                 false,
23256         },
23257         {
23258                 "spoolss_ResetPrinterEx",
23259                 sizeof(struct spoolss_ResetPrinterEx),
23260                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
23261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
23262                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
23263                 false,
23264         },
23265         {
23266                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
23267                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
23268                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23270                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23271                 false,
23272         },
23273         {
23274                 "spoolss_RouterReplyPrinterEx",
23275                 sizeof(struct spoolss_RouterReplyPrinterEx),
23276                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
23277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
23278                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
23279                 false,
23280         },
23281         {
23282                 "spoolss_RouterRefreshPrinterChangeNotify",
23283                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
23284                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
23285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
23286                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
23287                 false,
23288         },
23289         {
23290                 "spoolss_44",
23291                 sizeof(struct spoolss_44),
23292                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
23293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
23294                 (ndr_print_function_t) ndr_print_spoolss_44,
23295                 false,
23296         },
23297         {
23298                 "spoolss_OpenPrinterEx",
23299                 sizeof(struct spoolss_OpenPrinterEx),
23300                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
23301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
23302                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
23303                 false,
23304         },
23305         {
23306                 "spoolss_AddPrinterEx",
23307                 sizeof(struct spoolss_AddPrinterEx),
23308                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
23309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
23310                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
23311                 false,
23312         },
23313         {
23314                 "spoolss_47",
23315                 sizeof(struct spoolss_47),
23316                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
23317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
23318                 (ndr_print_function_t) ndr_print_spoolss_47,
23319                 false,
23320         },
23321         {
23322                 "spoolss_EnumPrinterData",
23323                 sizeof(struct spoolss_EnumPrinterData),
23324                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
23325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
23326                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
23327                 false,
23328         },
23329         {
23330                 "spoolss_DeletePrinterData",
23331                 sizeof(struct spoolss_DeletePrinterData),
23332                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
23333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
23334                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
23335                 false,
23336         },
23337         {
23338                 "spoolss_4a",
23339                 sizeof(struct spoolss_4a),
23340                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
23341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
23342                 (ndr_print_function_t) ndr_print_spoolss_4a,
23343                 false,
23344         },
23345         {
23346                 "spoolss_4b",
23347                 sizeof(struct spoolss_4b),
23348                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
23349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
23350                 (ndr_print_function_t) ndr_print_spoolss_4b,
23351                 false,
23352         },
23353         {
23354                 "spoolss_4c",
23355                 sizeof(struct spoolss_4c),
23356                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
23357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
23358                 (ndr_print_function_t) ndr_print_spoolss_4c,
23359                 false,
23360         },
23361         {
23362                 "spoolss_SetPrinterDataEx",
23363                 sizeof(struct spoolss_SetPrinterDataEx),
23364                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
23365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
23366                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
23367                 false,
23368         },
23369         {
23370                 "spoolss_GetPrinterDataEx",
23371                 sizeof(struct spoolss_GetPrinterDataEx),
23372                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
23373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
23374                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
23375                 false,
23376         },
23377         {
23378                 "spoolss_EnumPrinterDataEx",
23379                 sizeof(struct spoolss_EnumPrinterDataEx),
23380                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
23381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
23382                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
23383                 false,
23384         },
23385         {
23386                 "spoolss_EnumPrinterKey",
23387                 sizeof(struct spoolss_EnumPrinterKey),
23388                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
23389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
23390                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
23391                 false,
23392         },
23393         {
23394                 "spoolss_DeletePrinterDataEx",
23395                 sizeof(struct spoolss_DeletePrinterDataEx),
23396                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
23397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
23398                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
23399                 false,
23400         },
23401         {
23402                 "spoolss_DeletePrinterKey",
23403                 sizeof(struct spoolss_DeletePrinterKey),
23404                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
23405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
23406                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
23407                 false,
23408         },
23409         {
23410                 "spoolss_53",
23411                 sizeof(struct spoolss_53),
23412                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
23413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
23414                 (ndr_print_function_t) ndr_print_spoolss_53,
23415                 false,
23416         },
23417         {
23418                 "spoolss_DeletePrinterDriverEx",
23419                 sizeof(struct spoolss_DeletePrinterDriverEx),
23420                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
23421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
23422                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
23423                 false,
23424         },
23425         {
23426                 "spoolss_55",
23427                 sizeof(struct spoolss_55),
23428                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
23429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
23430                 (ndr_print_function_t) ndr_print_spoolss_55,
23431                 false,
23432         },
23433         {
23434                 "spoolss_56",
23435                 sizeof(struct spoolss_56),
23436                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
23437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
23438                 (ndr_print_function_t) ndr_print_spoolss_56,
23439                 false,
23440         },
23441         {
23442                 "spoolss_57",
23443                 sizeof(struct spoolss_57),
23444                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
23445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
23446                 (ndr_print_function_t) ndr_print_spoolss_57,
23447                 false,
23448         },
23449         {
23450                 "spoolss_XcvData",
23451                 sizeof(struct spoolss_XcvData),
23452                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
23453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
23454                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
23455                 false,
23456         },
23457         {
23458                 "spoolss_AddPrinterDriverEx",
23459                 sizeof(struct spoolss_AddPrinterDriverEx),
23460                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
23461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
23462                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
23463                 false,
23464         },
23465         {
23466                 "spoolss_5a",
23467                 sizeof(struct spoolss_5a),
23468                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
23469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
23470                 (ndr_print_function_t) ndr_print_spoolss_5a,
23471                 false,
23472         },
23473         {
23474                 "spoolss_5b",
23475                 sizeof(struct spoolss_5b),
23476                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
23477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
23478                 (ndr_print_function_t) ndr_print_spoolss_5b,
23479                 false,
23480         },
23481         {
23482                 "spoolss_5c",
23483                 sizeof(struct spoolss_5c),
23484                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
23485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
23486                 (ndr_print_function_t) ndr_print_spoolss_5c,
23487                 false,
23488         },
23489         {
23490                 "spoolss_5d",
23491                 sizeof(struct spoolss_5d),
23492                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
23493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
23494                 (ndr_print_function_t) ndr_print_spoolss_5d,
23495                 false,
23496         },
23497         {
23498                 "spoolss_5e",
23499                 sizeof(struct spoolss_5e),
23500                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
23501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
23502                 (ndr_print_function_t) ndr_print_spoolss_5e,
23503                 false,
23504         },
23505         {
23506                 "spoolss_5f",
23507                 sizeof(struct spoolss_5f),
23508                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
23509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
23510                 (ndr_print_function_t) ndr_print_spoolss_5f,
23511                 false,
23512         },
23513         { NULL, 0, NULL, NULL, NULL, false }
23514 };
23515
23516 static const char * const spoolss_endpoint_strings[] = {
23517         "ncacn_np:[\\pipe\\spoolss]",
23518 };
23519
23520 static const struct ndr_interface_string_array spoolss_endpoints = {
23521         .count  = 1,
23522         .names  = spoolss_endpoint_strings
23523 };
23524
23525 static const char * const spoolss_authservice_strings[] = {
23526         "host",
23527 };
23528
23529 static const struct ndr_interface_string_array spoolss_authservices = {
23530         .count  = 1,
23531         .names  = spoolss_authservice_strings
23532 };
23533
23534
23535 const struct ndr_interface_table ndr_table_spoolss = {
23536         .name           = "spoolss",
23537         .syntax_id      = {
23538                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
23539                 NDR_SPOOLSS_VERSION
23540         },
23541         .helpstring     = NDR_SPOOLSS_HELPSTRING,
23542         .num_calls      = 114,
23543         .calls          = spoolss_calls,
23544         .endpoints      = &spoolss_endpoints,
23545         .authservices   = &spoolss_authservices
23546 };
23547